├── images ├── FWD.png ├── load.png ├── N_layer.png ├── VE_mesh.png ├── bessel1.png ├── backcalc1.png ├── interface.png ├── Roadmap_ALVA.png ├── Validation1.png ├── Validation2.png ├── Validation3.png ├── Validation4.png ├── Validation5.png ├── Validation6.png └── backcalc1_f0.png ├── basic ├── init_LET.m ├── B0r_table.mat ├── B1r_table.mat ├── arb_func_interp.m ├── besselroots.m ├── VE_moduli.m ├── inv_loop.m ├── VE_response.m ├── VE_simulation.m ├── arb_func_polfit.m ├── polfit_abc.m ├── polfit_int.m ├── lookup_gauss.m ├── numint_coeff_plain.m ├── numint_coeff.m ├── LET_response_polfit.m ├── arb_func_plain.m ├── arb_func.m ├── LET_response_plain.m └── LET_response.m ├── validation ├── validation_boussinesq.m ├── validation_ve.m └── validation_let.m ├── paper.bib ├── examples ├── ALVA_let_backcalculation.m ├── ALVA_let_validation3.m ├── ALVA_let_validation4.m ├── ALVA_let_validation5.m ├── ALVA_let_validation1.m ├── ALVA_visco_validation1.m ├── ALVA_let_validation2.m └── ALVA_bonding_validation1.m ├── paper.md └── LICENSE /images/FWD.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/FWD.png -------------------------------------------------------------------------------- /basic/init_LET.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/basic/init_LET.m -------------------------------------------------------------------------------- /images/load.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/load.png -------------------------------------------------------------------------------- /basic/B0r_table.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/basic/B0r_table.mat -------------------------------------------------------------------------------- /basic/B1r_table.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/basic/B1r_table.mat -------------------------------------------------------------------------------- /images/N_layer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/N_layer.png -------------------------------------------------------------------------------- /images/VE_mesh.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/VE_mesh.png -------------------------------------------------------------------------------- /images/bessel1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/bessel1.png -------------------------------------------------------------------------------- /images/backcalc1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/backcalc1.png -------------------------------------------------------------------------------- /images/interface.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/interface.png -------------------------------------------------------------------------------- /images/Roadmap_ALVA.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/Roadmap_ALVA.png -------------------------------------------------------------------------------- /images/Validation1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/Validation1.png -------------------------------------------------------------------------------- /images/Validation2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/Validation2.png -------------------------------------------------------------------------------- /images/Validation3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/Validation3.png -------------------------------------------------------------------------------- /images/Validation4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/Validation4.png -------------------------------------------------------------------------------- /images/Validation5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/Validation5.png -------------------------------------------------------------------------------- /images/Validation6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/Validation6.png -------------------------------------------------------------------------------- /images/backcalc1_f0.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/images/backcalc1_f0.png -------------------------------------------------------------------------------- /validation/validation_boussinesq.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asmusskar/ALVA/HEAD/validation/validation_boussinesq.m -------------------------------------------------------------------------------- /basic/arb_func_interp.m: -------------------------------------------------------------------------------- 1 | function ABCDi = arb_func_interp(n,xip,ABCD) 2 | 3 | %------------------------------------------------------------------------- 4 | % DESCRIPTION: 5 | % This function utilizes a cubic spline interpolation scheme to return 6 | % interpolated values for sought integration points (xip) based on the 7 | % calculated solutions for the coefficients of integration (arbitrary 8 | % functions). 9 | 10 | % INPUT PARAMETERS: 11 | % n: Number of layers (including half space layer), i.e. n = length(E) 12 | % xip: Sought integration points 13 | % ABCD: Arbitrary function values (soultion points) to be interpolated. 14 | %------------------------------------------------------------------------- 15 | m = ABCD(end,:); 16 | ABCD = ABCD(1:end-1,:); 17 | for i=1:4*n 18 | ABCDi(i,:) = interp1(m,ABCD(i,:),xip,'PCHIP'); 19 | end -------------------------------------------------------------------------------- /basic/besselroots.m: -------------------------------------------------------------------------------- 1 | function x = besselroots(o,N,k) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function looks up the zeros roots of Bessel function of order 0 and 5 | % 1 of the first kind. Up to 1000 points is considered. 6 | 7 | % INPUT PARAMETERS 8 | % o : Order of the bessel function 9 | % N : Number of Bessel roots in integration 10 | % k : kind: 1 or 2 11 | % 1) Bessel's differential equation that are finite at the origin 12 | % 2) Bessel differential equation that have a singularity at the origin 13 | %-------------------------------------------------------------------------- 14 | 15 | if o == 0 && k == 1 16 | load B0r_table 17 | x = B0r(1:N); % Bessel 0 roots (B0r) 18 | elseif o == 1 && k == 1 19 | load B1r_table 20 | x = B1r(1:N); % Bessel 1 roots (B1r) 21 | else 22 | disp('Not supported') 23 | end 24 | -------------------------------------------------------------------------------- /basic/VE_moduli.m: -------------------------------------------------------------------------------- 1 | function alva = VE_moduli(D0,Dinf,tauD,nD,alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function determines the creep compliance modulus and relaxation 5 | % modulus at selected time increments 6 | 7 | % INPUT PARAMETERS 8 | % ti : Time increments [s] 9 | % tt : Total travel time [s] 10 | % D0 : Instantaneous or glassy compliance, [1/MPa] 11 | % Dinf : Long time equilibrium or rubbery compliance [1/MPa] 12 | % tauD : Retardation time of the material response [s] 13 | % nD : Slope of the creep curve in the transient region [-] 14 | %-------------------------------------------------------------------------- 15 | 16 | ti = alva.ti; 17 | tt = alva.tt; 18 | time = zeros(ti,1); 19 | Et = zeros(ti,1); 20 | E0 = 1/D0; 21 | Einf = 1/Dinf; 22 | 23 | for i=1:ti 24 | if i==1 25 | time(i) = 0; 26 | else 27 | time(i) = tt/10^(ti-i); 28 | end 29 | % Dt = Dinf +((D0-Dinf)/(1+(time(i)/tauD)^nD)); 30 | Et(i) = Einf*(1+(time(i)/tauD)^nD)/((time(i)/tauD)^nD+(Einf/E0)); 31 | end 32 | 33 | alva.Et = Et; 34 | alva.time = time; -------------------------------------------------------------------------------- /basic/inv_loop.m: -------------------------------------------------------------------------------- 1 | function o = inv_loop(X,alva) 2 | 3 | %-------------------------------------------------------------------------- 4 | % This file is an example file that calculates the displacements measured 5 | % from a Falling Weight Deflectometer (FWD) test based on the layered elastic 6 | % theory and minimize error compared to measured values while predicting 7 | % E-modulus for each layer 8 | 9 | % INPUT PARAMETERS 10 | % E : Layer Young's moduli 11 | % Xd : Sensor locations / evaluation points 12 | %-------------------------------------------------------------------------- 13 | 14 | if length(X)==1 15 | E = [X(1) X(1)]; % Initial Young's Modulus for single layer 16 | else 17 | E = X(1:1:end); 18 | end 19 | 20 | E = (10.^(E.*8)); 21 | 22 | % Variable input parameters 23 | alva.E = E; 24 | 25 | % Constant input parameters 26 | alva.Xd = [alva.gpos' zeros(length(alva.gpos),1) zeros(length(alva.gpos),1)]; 27 | 28 | % Calculate response 29 | alva = init_LET(alva); 30 | 31 | % Calculate (normalized) difference between measured and calculated 32 | % response 33 | dd = (alva.dFWD - alva.uz')./alva.dFWD; 34 | 35 | % Error function (sum of squared relative differences) 36 | o = 1/length(alva.dFWD)*sqrt(dd*dd'); 37 | 38 | 39 | 40 | -------------------------------------------------------------------------------- /basic/VE_response.m: -------------------------------------------------------------------------------- 1 | function alva = VE_response(E,alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function calculates the elastic response at selected locations 5 | % prior to spline interpolation 6 | 7 | % INPUT PARAMETERS 8 | % x : Coordinates of knots 9 | % ti : Time increments 10 | % E : Layer Young's moduli [MPa] 11 | % Et : Relaxation modulus [MPa] 12 | % alva : System parameters (e.g., load config etc.) 13 | %-------------------------------------------------------------------------- 14 | 15 | Xd = alva.Xd; 16 | ti = alva.ti; 17 | Et = alva.Et; 18 | 19 | % Initialize response parameters 20 | dx = zeros(length(Xd),length(ti)); dy = dx; dz = dx; 21 | sigx = dx; sigy = dx; sigz = dx; sigxy = dx; sigyz = dx; sigxz = dx; 22 | epsx = dx; epsy = dx; epsz = dx; epsxy = dx; epsyz = dx; epsxz = dx; 23 | 24 | for i=1:ti 25 | E(1) = Et(i); 26 | alva.E = E; 27 | alva = init_LET(alva); 28 | 29 | % Displacements 30 | dx(:,i) = alva.ux; % [mm] 31 | dy(:,i) = alva.uy; % [mm] 32 | dz(:,i) = alva.uz; % [mm] 33 | 34 | if strcmp(alva.analysis,'Full') 35 | % Stresses 36 | sigx(:,i) = alva.sigx; % [MPa] 37 | sigy(:,i) = alva.sigy; % [MPa] 38 | sigz(:,i) = alva.sigz; % [MPa] 39 | sigxy(:,i) = alva.sigxy; % [MPa] 40 | sigyz(:,i) = alva.sigyz; % [MPa] 41 | sigxz(:,i) = alva.sigxz; % [MPa] 42 | 43 | % Strains 44 | epsx(:,i) = alva.epsx.*1e6; % [micro strain] 45 | epsy(:,i) = alva.epsy.*1e6; % [micro strain] 46 | epsz(:,i) = alva.epsz.*1e6; % [micro strain] 47 | epsxy(:,i) = alva.epsxy.*1e6; % [micro strain] 48 | epsyz(:,i) = alva.epsyz.*1e6; % [micro strain] 49 | epsxz(:,i) = alva.epsxz.*1e6; % [micro strain] 50 | end 51 | end 52 | 53 | % Store displacements 54 | alva.dxm = dx; alva.dym = dy; alva.dzm = dz; 55 | 56 | % Store stresses 57 | alva.sigxm = sigx; alva.sigym = sigy; alva.sigzm = sigz; 58 | alva.sigxym = sigxy; alva.sigyzm = sigyz; alva.sigxzm = sigxz; 59 | 60 | % Store strains 61 | alva.epsxm = epsx; alva.epsym = epsy; alva.epszm = epsz; 62 | alva.epsxym = epsxy; alva.epsyzm = epsyz; alva.epsxzm = epsxz; 63 | -------------------------------------------------------------------------------- /basic/VE_simulation.m: -------------------------------------------------------------------------------- 1 | function evres = VE_simulation(letres,alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function construct a matrix of response at different times 5 | % (i.e., for different moduli) used for simulating a moving load 6 | 7 | % INPUT PARAMETERS 8 | % dt : Time increments moving vehicle 9 | % Xr : Refined mesh 10 | % Xd : Output coordinates (x,y,z) 11 | % ti : Time increments complience curve 12 | % letres: Linear elastic response in knots 13 | %-------------------------------------------------------------------------- 14 | 15 | dt = alva.dt; 16 | Xr = alva.Xr; 17 | Xd = alva.Xd; 18 | ti = alva.ti; 19 | time = alva.time; 20 | 21 | % Initialize parameters for refined mesh 22 | rp = zeros(length(Xr),1); 23 | rr = zeros(length(Xr),length(ti)); 24 | xs = Xd(:,1); 25 | xr = Xr(:,1); 26 | 27 | % Find response for refined mesh using cubic spline interpolation 28 | for j=1:ti 29 | rs = letres(:,j); 30 | for i=1:length(Xr) 31 | rp(i) = spline(xs,rs,xr(i)); 32 | end 33 | rr(:,j) = rp; 34 | end 35 | 36 | % Mirror response for -x0 to x0 37 | % Response at time t=0...t=tt, i.e. [R(t0), R(t1), R(t2)...R(tt)] 38 | rr =[flipud(rr(2:1:end,:)); rr]; 39 | 40 | % Start interpolating beween all the time increments 41 | % -> resulting in a row no.: position / collumn no.:time matrix 42 | r = zeros(length(rr),length(rr)); 43 | for i=1:length(rr) 44 | t = (i-1)*dt; 45 | if i==1 46 | r(:,1)=rr(:,1); 47 | elseif i > 1 && i < length(rr) 48 | idt2 = min(find(time > t)); 49 | idt1 = idt2-1; 50 | r1 = rr(:,idt1); 51 | r2 = rr(:,idt2); 52 | r(:,i) = r1 + ((r2-r1)/(time(idt2)-time(idt1)))*(t-time(idt1)); 53 | elseif i==length(rr) 54 | r(:,i) = rr(:,end); 55 | end 56 | end 57 | 58 | % Simulate moving load: Start point = -x0, Point of interest = 0, 59 | % i.e. load point = 0 and response point = x0 60 | 61 | % Pseudo-code 62 | % t0: R(E(0),x(0)) 63 | % t1: R(E(0),x(dx)) +R(E(dt),x(0)) -R(E(0),x(0)) 64 | % t2: R(E(0),x(2dx))+R(E(dt),x(dx))-R(E(0),x(dx))+R(E(2dt),x(0))-R(E(dt),x(0)) 65 | 66 | evres = zeros(length(rr),1); % response at evaluation point 67 | for i=1:length(rr) 68 | k=-(length(rr)-1)+(i-1); 69 | if i==1 70 | evres(i)=sum(diag(r,k)); 71 | else 72 | rp = diag(r,k); 73 | rn = diag(r,k-1); 74 | evres(i) = sum(rp)-sum(rn); 75 | end 76 | kk(i)=k; 77 | end -------------------------------------------------------------------------------- /basic/arb_func_polfit.m: -------------------------------------------------------------------------------- 1 | function [Az,Bz,Cz,Dz,Ar,Br,Cr,Dr]=arb_func_polfit(E,nu,zi,xip_z,xip_r,lr,alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function interpolates intermediate values for A, B, C and D by 5 | % linear interpolation. This is done by taking one full sequence of A, B, C 6 | % and D values for one 'load-to-deformation-point'-case and interpolate the 7 | % remaning cases based on these values. 8 | 9 | % INPUT PARAMETERS: 10 | % xip_z , xip_r : integration points 11 | % zi , ri : row numbers where xip_z and xip_r contain the highest 12 | % end value 13 | % A1, B1, C1 and D1 : coefficients for uz evaluated in xip_z(zi,:) 14 | % A2, B2, C2 and D2 : coefficients for ur evaluated in xip_r(ri,:) 15 | % lr : number of 'load-to-deformation-point' radii 16 | %-------------------------------------------------------------------------- 17 | 18 | % Identify the largest xip values (i.e. largest interval) in xip_z and 19 | % xip_r, respectively. 20 | [xmax , xiz] = max(xip_z(:,end)); 21 | [xmax , xir] = max(xip_r(:,end)); 22 | 23 | % Define the rows with the largest interval 24 | xipz = xip_z(xiz,:); 25 | xipr = xip_r(xir,:); 26 | 27 | % Evaluate A, B, C and D in the points xipz 28 | ABCD = arb_func_plain(length(E),xipz,zi,E,nu,alva); 29 | 30 | Az = ABCD(1,:); % Layer 1 A values 31 | Bz = ABCD(2,:); % ... B ... 32 | Cz = ABCD(3,:); % ... C ... 33 | Dz = ABCD(4,:); % ... D ... 34 | 35 | % Evaluate A, B, C and D in the points xipr 36 | ABCD = arb_func_plain(length(E),xipr,zi,E,nu,alva); 37 | 38 | Ar = ABCD(1,:); % Layer 1 A values 39 | Br = ABCD(2,:); % ... B ... 40 | Cr = ABCD(3,:); % ... C ... 41 | Dr = ABCD(4,:); % ... D ... 42 | 43 | % Number of integration points (and A, B, C and D values) per radius 44 | nz = size(xip_z,2); 45 | 46 | % Evaluate Az, Bz, Cz and Dz by interpolation from xip, A, B, C and D 47 | xip_z = xip_z'; 48 | Az = spline(xipz,Az,xip_z(:)); 49 | Bz = spline(xipz,Bz,xip_z(:)); 50 | Cz = spline(xipz,Cz,xip_z(:)); 51 | Dz = spline(xipz,Dz,xip_z(:)); 52 | 53 | % Evaluate Ar, Br, Cr and Dr by interpolation from xip, A, B, C and D 54 | xip_r = xip_r'; 55 | Ar = spline(xipr,Ar,xip_r(:)); 56 | Br = spline(xipr,Br,xip_r(:)); 57 | Cr = spline(xipr,Cr,xip_r(:)); 58 | Dr = spline(xipr,Dr,xip_r(:)); 59 | 60 | % Reorganize content of Az, Bz, Cz and Dz. 61 | Az = reshape(Az,[nz,lr])'; 62 | Bz = reshape(Bz,[nz,lr])'; 63 | Cz = reshape(Cz,[nz,lr])'; 64 | Dz = reshape(Dz,[nz,lr])'; 65 | 66 | % Reorganize content of Ar, Br, Cr and Dr. 67 | Ar = reshape(Ar,[nz,lr])'; 68 | Br = reshape(Br,[nz,lr])'; 69 | Cr = reshape(Cr,[nz,lr])'; 70 | Dr = reshape(Dr,[nz,lr])'; -------------------------------------------------------------------------------- /basic/polfit_abc.m: -------------------------------------------------------------------------------- 1 | function abc_zr = polfit_abc(E,nu,zi,Lam1,alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function evaluates the a, b and c-value for the polynomial in the 5 | % approximation method used (see [1]) to speed up the integration. The 6 | % output abc-matrix contains the abc constants in two rows. Row 1 the 7 | % z-related values and row 2 the r-related values 8 | 9 | % The polynomial approximations: 10 | % uz: f1(m) = (a*m^2+b*m+c)*exp(-2*lam1*m)-(2-2*Nu) % for uz deformations 11 | % ur: f2(m) = (a*m^2+b*m+c2)*exp(-2*lam1*m)-(1-2*Nu) % for ur deformations 12 | 13 | % INPUT PARAMETERS: 14 | % Lam1 : relative depth of top layer (=z1/H) 15 | % A, B, C, D : integral parameters 16 | % xip_z, xip_r : integration points 17 | % nu : poisson's ratio 18 | % E : Young's moduli 19 | 20 | % ------------------------------------------------------------------------- 21 | % References 22 | % ------------------------------------------------------------------------- 23 | %[1] Andersen, S., Levenberg, E., & Andersen, M. B (2020). Efficient 24 | % reevaluation of surface displacements in a layered elastic half-space. 25 | % The International Journal of Pavement Engineering 21(4), 1-8. 26 | % https://doi.org/10.1080/10298436.2018.1483502 27 | %-------------------------------------------------------------------------- 28 | 29 | alpha = [0.01 0.05 0.1]/100; 30 | mz = 1/(2*Lam1)*log(-1./(alpha*(2*nu(1)-2))); 31 | mr = 1/(2*Lam1)*log(-1./(alpha*(2*nu(1)-1))); 32 | 33 | % Evaluate A, B, C and D values used for evaulation of a, b and c 34 | ABCD = arb_func_plain(length(E),mz,zi,E,nu,alva); 35 | 36 | Azi = ABCD(1,:)'; % Layer 1 A value 37 | Bzi = ABCD(2,:)'; % ... B ... 38 | Czi = ABCD(3,:)'; % ... C ... 39 | Dzi = ABCD(4,:)'; % ... D ... 40 | 41 | ABCD = arb_func_plain(length(E),mr,zi,E,nu,alva); 42 | Ari = ABCD(1,:)'; % Layer 1 A value 43 | Bri = ABCD(2,:)'; % ... B ... 44 | Cri = ABCD(3,:)'; % ... C ... 45 | Dri = ABCD(4,:)'; % ... D ... 46 | 47 | %%%%%%% Evaluate coefficients for polynomial approximations %%%%%%%% 48 | m1 = mz(1); 49 | m2 = mz(2); 50 | m3 = mz(3); 51 | 52 | % Denominators 53 | den1 = (m1-m3)*(m1-m2); % denominator 1 54 | den2 = (m2-m3)*(m1-m2); % denominator 2 55 | den3 = (m2-m3)*(m1-m3); % denominator 3 56 | 57 | % Organize inverted matrix used in the evaluation abc = Mi*Rhs 58 | Mz = [ exp(2*Lam1*m1)/den1 , -exp(2*Lam1*m2)/den2 , exp(2*Lam1*m3)/den3 59 | -exp(2*Lam1*m1)*(m2+m3)/den1 , exp(2*Lam1*m2)*(m1+m3)/den2 , -exp(2*Lam1*m3)*(m1+m2)/den3 60 | exp(2*Lam1*m1)*m2*m3/den1 , -exp(2*Lam1*m2)*m1*m3/den2 , exp(2*Lam1*m3)*m1*m2/den3 ]; 61 | 62 | % For the radial displacements 63 | m1 = mr(1); 64 | m2 = mr(2); 65 | m3 = mr(3); 66 | 67 | % Denominators 68 | den1 = (m1-m3)*(m1-m2); % denominator 1 69 | den2 = (m2-m3)*(m1-m2); % denominator 2 70 | den3 = (m2-m3)*(m1-m3); % denominator 3 71 | 72 | % Organize inverted matrix udsed in abc = Mi*Rhs 73 | Mr = [ exp(2*Lam1*m1)/den1 , -exp(2*Lam1*m2)/den2 , exp(2*Lam1*m3)/den3 74 | -exp(2*Lam1*m1)*(m2+m3)/den1 , exp(2*Lam1*m2)*(m1+m3)/den2 , -exp(2*Lam1*m3)*(m1+m2)/den3 75 | exp(2*Lam1*m1)*m2*m3/den1 , -exp(2*Lam1*m2)*m1*m3/den2 , exp(2*Lam1*m3)*m1*m2/den3 ]; 76 | 77 | % Evaluate a, b and c coefficients for uz integration 78 | abc_zr = zeros(2,3); 79 | 80 | % Evaluate the uz-related paramters 81 | Rhs_z = (Azi - Czi*(2-4*nu(1))).*exp(-mz'*Lam1) - (Bzi+Dzi*(2-4*nu(1))) + (2-2*nu(1)); 82 | abc_zr(1,:) = Mz*Rhs_z; 83 | 84 | % Evaluate the ur-related paramters 85 | Rhs_r = (Ari + Cri).*exp(-mr'*Lam1) + Bri-Dri + (1-2*nu(1)); 86 | abc_zr(2,:) = Mr*Rhs_r; 87 | 88 | % Set a, b, c equal to zero if E1 approx. E2 approx. = E3*... 89 | if (max(E)-min(E))/max(E)*100 < 5 90 | abc_zr = zeros(2,3); 91 | end 92 | 93 | % *Note: If all layer moduli are equal, i.e., E1 = E2 = E3 = ... we have a 94 | % half-space (one layer) solution and a = b = c = 0. Numerical noise can 95 | % be experienced if E1 approx E2 approx E3 ... A tolerence is therfore 96 | % introduced, set to 5%, i.e., if 0.95*E1 <= E2 <= 1.05*E1, a, b og c is 0, 97 | % This is because its mathematically may lead to some isssues determining 98 | % a, b og c, and because we are so close to the half-space solution. This 99 | % special case is only used when all layer moduli are approx. equal. If one 100 | % layer moduli differ more than 5%, its treated as a multi-layered model 101 | -------------------------------------------------------------------------------- /paper.bib: -------------------------------------------------------------------------------- 1 | @report{amadeus:2000a, 2 | title = {Advanced models for analytical design of European pavement 3 | structures}, 4 | note = {Report no. RO-97-SC.2137}, 5 | author = {{Belgian Road Research Centre}}, 6 | organization = {European Commission}, 7 | address = {Brussels, Belgium}, 8 | year = {2000}, 9 | url = {https://trimis.ec.europa.eu/project/advanced-models-analytical-design-european-pavement-structures}, 10 | } 11 | 12 | @article{Andersen:2020a, 13 | title = {Efficient reevaluation of surface displacements in a layered elastic half-space}, 14 | language = {eng}, 15 | publisher = {Taylor and Francis Ltd.}, 16 | journal = {International Journal of Pavement Engineering}, 17 | volume = {21}, 18 | number = {4}, 19 | pages = {408-415}, 20 | year = {2020}, 21 | issn = {1477268x, 10298436}, 22 | doi = {10.1080/10298436.2018.1483502}, 23 | author = {Andersen, Sebastian and Levenberg, Eyal and Andersen, Mathias B.} 24 | } 25 | 26 | @article{Burmister:1945a, 27 | title = {The general theory of stresses and displacements in layered systems. I-III}, 28 | language = {und}, 29 | journal = {Journal of Applied Physics}, 30 | volume = {16}, 31 | pages = {89-94, 89-94}, 32 | year = {1945}, 33 | author = {Burmister} 34 | } 35 | 36 | @article{Chabot:2010a, 37 | title = {ViscoRoute 2.0 A: Tool for the Simulation of Moving Load Effects on Asphalt Pavement}, 38 | language = {eng}, 39 | publisher = {Informa UK Limited}, 40 | journal = {Road Materials and Pavement Design}, 41 | volume = {11}, 42 | number = {2}, 43 | pages = {227-250}, 44 | year = {2010}, 45 | issn = {21647402, 14680629}, 46 | doi = {10.1080/14680629.2010.9690274}, 47 | author = {Chabot, Armelle and Chupin, Olivier and Deloffre, Lydie and Duhamel, Denis} 48 | } 49 | 50 | @article{Erlingsson:2013a, 51 | title = {Fast layered elastic response program for the analysis of flexible pavement structures}, 52 | language = {eng}, 53 | publisher = {TAYLOR & FRANCIS LTD}, 54 | journal = {Road Materials and Pavement Design}, 55 | volume = {14}, 56 | number = {1}, 57 | pages = {196-210}, 58 | year = {2013}, 59 | issn = {21647402, 14680629}, 60 | doi = {10.1080/14680629.2012.757558}, 61 | author = {Erlingsson, Sigurdur and Ahmed, Abubeker W.} 62 | } 63 | 64 | @article{khazanovich:2007a, 65 | title = {MnLayer: High-performance layered elastic analysis program}, 66 | language = {eng}, 67 | publisher = {NATL ACAD SCIENCES}, 68 | journal = {Transportation Research Record}, 69 | volume = {2037}, 70 | number = {2037}, 71 | pages = {63-75}, 72 | year = {2007}, 73 | issn = {03611981, 21694052}, 74 | isbn = {9780309113014}, 75 | doi = {10.3141/2037-06}, 76 | author = {Khazanovich, Lev and Wang, Qiang} 77 | } 78 | 79 | @article{Levenberg:2016a, 80 | title={ELLEA1: Isotropic Layered Elasticity in Excel: Pavement analysis tool for students and engineers}, 81 | author={Levenberg, Eyal}, 82 | year={2016} 83 | } 84 | 85 | @article{Levenberg:2016b, 86 | title={ELLVA1: Isotropic Layered Viscoelasticity in Excel (moving load): Advanced pavement analysis tool for students and engineers}, 87 | author={Levenberg, Eyal}, 88 | year={2016} 89 | } 90 | 91 | @article{Levenberg:2016c, 92 | title = {Viscoelastic Pavement Modeling with a Spreadsheet}, 93 | language = {eng}, 94 | publisher = {Research Publishing Services}, 95 | journal = {Proceedings of the Eighth International Conference on Maintenance and Rehabilitation of Pavements (mairepav8)}, 96 | pages = {746-755}, 97 | year = {2016}, 98 | isbn = {9789811104497}, 99 | doi = {10.3850/978-981-11-0449-7-132-cd}, 100 | author = {Levenberg, Eyal} 101 | } 102 | 103 | @article{Levenberg:2020a, 104 | title = {Analytic pavement modelling with a fragmented layer}, 105 | language = {eng}, 106 | publisher = {Taylor and Francis Ltd.}, 107 | journal = {International Journal of Pavement Engineering}, 108 | pages = {1-13}, 109 | year = {2020}, 110 | issn = {1477268x, 10298436}, 111 | doi = {10.1080/10298436.2020.1790559}, 112 | author = {Levenberg, Eyal and Skar, Asmus} 113 | } 114 | 115 | @article{Maina:2004a, 116 | title = {Developing software for elastic analysis of pavement structure responses to vertical and horizontal surface loadings}, 117 | language = {eng}, 118 | publisher={SAGE Publications Sage CA: Los Angeles, CA}, 119 | journal = {Transportation Research Record}, 120 | volume = {1896}, 121 | number = {1896}, 122 | pages = {107-118}, 123 | year = {2004}, 124 | issn = {21694052, 03611981}, 125 | isbn = {0309094895}, 126 | doi = {10.3141/1896-11}, 127 | author = {Maina, James W. and Matsui, Kunihito} 128 | } 129 | 130 | @article{Skar:2020a, 131 | title = {Analysis of a moving measurement platform based on line profile sensors for project-level pavement evaluation}, 132 | language = {eng}, 133 | publisher = {Taylor and Francis Ltd.}, 134 | journal = {Road Materials and Pavement Design}, 135 | pages = {1-17}, 136 | year = {2020}, 137 | issn = {21647402, 14680629}, 138 | doi = {10.1080/14680629.2020.1741429}, 139 | author = {Skar, Asmus and Levenberg, Eyal and Andersen, Sebastian and Andersen, Mathias B.} 140 | } 141 | -------------------------------------------------------------------------------- /basic/polfit_int.m: -------------------------------------------------------------------------------- 1 | function I = polfit_int(Xd,Xl,a,H,Lam1,XipWip,Nu) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function evaluates the integrals Iz(i) and Ir(i) (i = 1,..,4) 5 | % in the approximation method used (see [1]). 6 | 7 | % INPUT PARAMETERS: 8 | % Xd : Coordinates of evaluation points (x,y,z) 9 | % Xl : Coordinates of load (x,y) 10 | % a : Load radii vector 11 | % H : Depth of layer n-1 out of n layers (i.e. thicness of structure) 12 | % Lam1 : Relative depth of the top layer 13 | % XipWip: Integration points and weights 14 | % ------------------------------------------------------------------------- 15 | % References 16 | % ------------------------------------------------------------------------- 17 | %[1] Andersen, S., Levenberg, E., & Andersen, M. B (2020). Efficient 18 | % reevaluation of surface displacements in a layered elastic half-space. 19 | % The International Journal of Pavement Engineering 21(4), 1-8. 20 | % https://doi.org/10.1080/10298436.2018.1483502 21 | %-------------------------------------------------------------------------- 22 | 23 | % Organize alpha and rho required for the integration 24 | 25 | % Number of loads (xl) and deformation points (xd) 26 | xl = size(Xl,1); % Number of load points 27 | xd = size(Xd,1); % Number of deformation points 28 | 29 | % Extend number of deformation points 30 | Xl = repmat(Xl,[xd,1]); % Extends matrix to number of evaluation points 31 | Xd = repmat(Xd,[xl,1]); % Xd is reorganized below to correspond to the 32 | % correct Xl content/sequence 33 | 34 | % Reorganize Xd so the first xl rows correspond to the same deformation 35 | % point, and following xl rows correspond to the next deformation point 36 | % etc... see description of the vector r nine lines below to understand the 37 | % organization 38 | 39 | % Built dx vector used to reorganize/sort Xd in the right order 40 | dx = repmat(1:xd,xl,1); 41 | dx = dx(:)' + repmat(0:xd:xd*(xl-1),1,xd); 42 | Xd = Xd(dx,:); 43 | 44 | % Evaluate the radii between evaluation point and load 45 | % r = [ evaluation point 1 and load 1 46 | % evaluation point 1 and load 2 47 | % evaluation point 1 and load 3 48 | % . 49 | % evaluation point 1 and load N 50 | % evaluation point 2 and load 1 51 | % evaluation point 2 and load 2 52 | % . 53 | % . 54 | % last evaluation point and load N]; 55 | 56 | r = sqrt((Xd(:,1)-Xl(:,1)).^2 + (Xd(:,2)-Xl(:,2)).^2); 57 | 58 | % Introduce the parameter rho (notice: since r is a vector, rho is too) 59 | rho = r/H; 60 | 61 | % Alpha - repeated by the number of deformation points all loads influence 62 | alpha = repmat(a/H,[xd,1]); 63 | %------------------------------------------------------------------------ 64 | % Integration points and weights 65 | 66 | lrho = length(rho); % Number of load-to-displacement-points 67 | xip_z = XipWip(0*lrho+1:1*lrho,:); 68 | wip_z = XipWip(1*lrho+1:2*lrho,:); 69 | xip_r = XipWip(2*lrho+1:3*lrho,:); 70 | wip_r = XipWip(3*lrho+1:4*lrho,:); 71 | 72 | % Number of columns in reorganized integration points and weights (= number 73 | % of integration points per integral) 74 | nz = size(xip_z,2); 75 | 76 | % Perform precalculated integrals of polynomial approximations 77 | 78 | % First integral Iz1 79 | Iz1 = besselj(0,xip_z.*repmat(rho,1,nz)).*(xip_z.^2.*exp(-2*Lam1*xip_z)); 80 | 81 | Iz1 = alpha.*(-1)*H.*(1+Nu).*... 82 | sum(Iz1.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z,2); 83 | 84 | % Second integral, Iz2 85 | Iz2 = besselj(0,xip_z.*repmat(rho,1,nz)).*(xip_z.*exp(-2*Lam1*xip_z)); 86 | 87 | Iz2 = alpha.*(-1)*H.*(1+Nu).*... 88 | sum(Iz2.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z,2); 89 | 90 | % Third integral, Iz3 91 | Iz3 = besselj(0,xip_z.*repmat(rho,1,nz)).*exp(-2*Lam1*xip_z); 92 | 93 | Iz3 = alpha.*(-1)*H.*(1+Nu).*... 94 | sum(Iz3.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z,2); 95 | 96 | % Fourth integral, Iz4 97 | Iz4 = besselj(0,xip_z.*repmat(rho,1,nz)).*(-(2-2*Nu)); 98 | 99 | Iz4 = alpha.*(-1)*H.*(1+Nu).*... 100 | sum(Iz4.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z,2); 101 | 102 | % First integral, Ir1 103 | Ir1 = besselj(1,xip_r.*repmat(rho,1,nz)).*(xip_r.^2.*exp(-2*Lam1*xip_r)); 104 | 105 | Ir1 = alpha.*H*(1+Nu).*sum(Ir1.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r,2); 106 | 107 | % Second integral, Ir2 108 | Ir2 = besselj(1,xip_r.*repmat(rho,1,nz)).*(xip_r.*exp(-2*Lam1*xip_r)); 109 | 110 | Ir2 = alpha.*H*(1+Nu).*sum(Ir2.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r,2); 111 | 112 | % Third integral, Ir3 113 | Ir3 = besselj(1,xip_r.*repmat(rho,1,nz)).*exp(-2*Lam1*xip_r); 114 | 115 | Ir3 = alpha.*H*(1+Nu).*sum(Ir3.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r,2); 116 | 117 | % Foruth integral, Ir4 118 | Ir4 = besselj(1,xip_r.*repmat(rho,1,nz)).*(-(1-2*Nu)); 119 | 120 | Ir4 = alpha.*H*(1+Nu).*sum(Ir4.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r,2); 121 | 122 | % Save all integration values in one matrix 123 | I = [Iz1 , Iz2 , Iz3 , Iz4 , Ir1 , Ir2 , Ir3 , Ir4]; -------------------------------------------------------------------------------- /examples/ALVA_let_backcalculation.m: -------------------------------------------------------------------------------- 1 | % DESCRIPTION: 2 | % This script tests the implementation of the ALVA LET model for inferring 3 | % layer moduli, or so called "backcalculation" of layer moduli, based on 4 | % Falling Weight Deflectometer (FWD) measurements. 5 | 6 | clear all, close all, clc 7 | 8 | % ------------------------------------------------------------------------- 9 | % Select response analysis type 10 | % ------------------------------------------------------------------------- 11 | alva.analysis = 'Full'; 12 | % 1) 'Full' : Conventional full integration with one-step Richardson 13 | % extrapolation (for improved convergence near surface) 14 | % applied for evaluation of displacements and stresses 15 | % 2) 'PolFit' : Use polynomial fit technique to reduce integral length 16 | % according to Andersen et al. (2018) for evaluation of 17 | % surface displacements 18 | 19 | % ------------------------------------------------------------------------- 20 | % Select interface 21 | % ------------------------------------------------------------------------- 22 | alva.bond = 'Bonded'; 23 | % 1) 'Bonded' : Full bonding between layers 24 | % 2) 'Slip' : Interface bonding factor 25 | % 3) 'Frictionless' : No bonding between layers 26 | 27 | % ------------------------------------------------------------------------- 28 | % Numerical parameters 29 | % ------------------------------------------------------------------------- 30 | alva.N = 300; % Number of Bessel zero points in numerical integration 31 | alva.n = 30; % Number of Gauss points points between zero points. 32 | 33 | % ------------------------------------------------------------------------- 34 | % Pavement material properties (minimum two layers required) 35 | % ------------------------------------------------------------------------- 36 | alva.zi = [161 421]; % Depth of first n-1 layers from the 37 | % surface [mm]: last z = inf, and should not 38 | % be added NB: zi(i) > zi(i-1) > z(i-2)... 39 | alva.nu = [0.35 0.35 0.35]; % Layer Poisson's ratio [-] 40 | alva.kh = [1e2 1e2]; % Interface bonding/horizontal spring [MPa/mm] 41 | 42 | % ------------------------------------------------------------------------- 43 | % Load configuration 44 | % ------------------------------------------------------------------------- 45 | alva.q = 0.7; % Load pressure [MPa] (uniform vertical pressure) 46 | alva.a = 150; % Load radii [mm] (circular load) 47 | alva.Xl = [0 0]; % Load positions [mm]: [x1 y1; x2 y2;..xi yi]; 48 | 49 | % ------------------------------------------------------------------------- 50 | % Sensor locations along x-axis in [mm] 51 | % ------------------------------------------------------------------------- 52 | 53 | alva.gpos = [0 200 300 450 600 900 1200 1500 1800]; 54 | 55 | % ------------------------------------------------------------------------- 56 | % Response measurements (vertical surface displacements, uz) in [mm] 57 | % ------------------------------------------------------------------------- 58 | 59 | alva.dFWD = [298.9 244.2 220.07 175.0 138.0 97.3 72.2 57.4 47.6].*1e-3; 60 | 61 | % ------------------------------------------------------------------------- 62 | % Initialize optimization problem 63 | % ------------------------------------------------------------------------- 64 | 65 | % Stop criteria 66 | tolfun = 1e-4; % Object function stop criteria 67 | tolvar = 1e-4; % Step size value stop criteria 68 | tolfval = 1e4; % Maximum function evaluations 69 | tolit = 1e3; % Maximum iterations 70 | options = optimset('PlotFcns',@optimplotfval,'MaxIter',tolit,... 71 | 'MaxFunEvals',tolfval,'TolFun',tolfun,'TolX',tolvar); 72 | 73 | % Initial parameters 74 | alva.E = [200 200 200]; % Layer Young's moduli [MPa] 75 | E0 = log10(alva.E)./8; % Transform and scale parameters 76 | x0 = E0; % Variable input 77 | 78 | % Run optimization algorithm 79 | [xmin,fval,exitflag,output] = fminsearch(@(x)inv_loop(x,alva),x0,options); 80 | 81 | fprintf('Iterations %d: ',output.iterations) 82 | fprintf('Relative error %f\n',fval) 83 | 84 | % ------------------------------------------------------------------------- 85 | % Get response for optimimal predicted E-moduli 86 | % ------------------------------------------------------------------------- 87 | alva.Xd = [ 88 | 0 0 0; 50 0 0; 100 0 0; 89 | 150 0 0; 200 0 0; 300 0 0; 90 | 450 0 0; 600 0 0; 900 0 0; 91 | 1200 0 0; 1500 0 0; 1800 0 0]; 92 | alva.E = 10.^(xmin.*8); 93 | alva = init_LET(alva); 94 | 95 | % ------------------------------------------------------------------------- 96 | % Plotting 97 | % ------------------------------------------------------------------------- 98 | 99 | figure, title('Deflection curve'); 100 | hold on, grid on 101 | plot(alva.gpos,alva.dFWD,'bo','LineWidth',1.25,'MarkerSize',5) 102 | hold on 103 | plot(alva.Xd(:,1),alva.uz,'-.r','LineWidth',1.0,'MarkerSize',6) 104 | hold on 105 | set(gca,'FontSize',9) 106 | legend({'Measured','Predicted'},'Location','SouthEast') 107 | axis ij 108 | xlabel('Distance from load, x-axis [mm]') 109 | ylabel('Displacement, u_{z} [mm]') 110 | hold off 111 | 112 | -------------------------------------------------------------------------------- /basic/lookup_gauss.m: -------------------------------------------------------------------------------- 1 | function [xp,wp] = lookup_gauss(n,a,b) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function evaluates Gauss points and weights for numerical 5 | % integration using Gauss quadrature. 6 | 7 | % INPUT PARAMETERS 8 | % n: Number of integration points 9 | % a: lower integration limit. 10 | % b: upper integration limit. 11 | %-------------------------------------------------------------------------- 12 | 13 | % Order of polynomium which is integrated exact 14 | p = 2*n-1; 15 | 16 | % Gauss points and weights 17 | if p <= 1 18 | wp = 2; 19 | xp = 0; 20 | elseif p <= 3 21 | wp = [1 1]; 22 | xp = [-1 1]/sqrt(3); 23 | elseif p <= 5 24 | wp = [5/9 8/9 5/9]; 25 | xp = [-sqrt(3/5) 0 sqrt(3/5)]; 26 | elseif p <= 7 27 | 28 | wp=[0.347854845137454 29 | 0.652145154862546 30 | 0.652145154862546 31 | 0.347854845137454]'; 32 | 33 | xp=[-0.861136311594053 34 | -0.339981043584856 35 | 0.339981043584856 36 | 0.861136311594053]'; 37 | 38 | elseif p <= 9 39 | 40 | wp=[0.236926885056189 41 | 0.478628670499366 42 | 0.568888888888889 43 | 0.478628670499366 44 | 0.236926885056189]'; 45 | 46 | xp=[-0.906179845938664 47 | -0.538469310105683 48 | 0 49 | 0.538469310105683 50 | 0.906179845938664]'; 51 | 52 | elseif p <=11 53 | 54 | wp = [0.171324492379170 55 | 0.360761573048139 56 | 0.467913934572691 57 | 0.467913934572691 58 | 0.360761573048139 59 | 0.171324492379170]'; 60 | 61 | xp = [-0.932469514203152 62 | -0.661209386466264 63 | -0.238619186083197 64 | 0.238619186083197 65 | 0.661209386466264 66 | 0.932469514203152]'; 67 | 68 | elseif p <=13 69 | 70 | wp=[ 0.129484966168870 71 | 0.279705391489277 72 | 0.381830050505119 73 | 0.417959183673469 74 | 0.381830050505119 75 | 0.279705391489277 76 | 0.129484966168870]'; 77 | 78 | xp=[ -0.949107912342758 79 | -0.741531185599394 80 | -0.405845151377397 81 | 0 82 | 0.405845151377397 83 | 0.741531185599394 84 | 0.949107912342758]'; 85 | 86 | elseif p <=15 87 | 88 | wp=[ 0.101228536290376 89 | 0.222381034453375 90 | 0.313706645877887 91 | 0.362683783378362 92 | 0.362683783378362 93 | 0.313706645877887 94 | 0.222381034453375 95 | 0.101228536290376]'; 96 | 97 | xp=[-0.960289856497536 98 | -0.796666477413627 99 | -0.525532409916329 100 | -0.183434642495650 101 | 0.183434642495650 102 | 0.525532409916329 103 | 0.796666477413627 104 | 0.960289856497536]'; 105 | 106 | elseif p <= 17 107 | 108 | wp=[ 0.081274388361574 109 | 0.180648160694857 110 | 0.260610696402935 111 | 0.312347077040003 112 | 0.330239355001260 113 | 0.312347077040003 114 | 0.260610696402935 115 | 0.180648160694857 116 | 0.081274388361574]'; 117 | 118 | xp=[-0.968160239507626 119 | -0.836031107326636 120 | -0.613371432700590 121 | -0.324253423403809 122 | 0 123 | 0.324253423403809 124 | 0.613371432700590 125 | 0.836031107326636 126 | 0.968160239507626]'; 127 | 128 | elseif p <= 19 129 | wp=[ 0.066671344308688 130 | 0.149451349150581 131 | 0.219086362515982 132 | 0.269266719309996 133 | 0.295524224714753 134 | 0.295524224714753 135 | 0.269266719309996 136 | 0.219086362515982 137 | 0.149451349150581 138 | 0.066671344308688]'; 139 | 140 | xp=[-0.973906528517172 141 | -0.865063366688985 142 | -0.679409568299024 143 | -0.433395394129247 144 | -0.148874338981631 145 | 0.148874338981631 146 | 0.433395394129247 147 | 0.679409568299024 148 | 0.865063366688985 149 | 0.973906528517172]'; 150 | 151 | elseif p <= 59 152 | wp=[0.007968192496167 153 | 0.018466468311091 154 | 0.028784707883323 155 | 0.038799192569627 156 | 0.048402672830594 157 | 0.057493156217619 158 | 0.065974229882181 159 | 0.073755974737705 160 | 0.080755895229420 161 | 0.086899787201083 162 | 0.092122522237786 163 | 0.096368737174644 164 | 0.099593420586795 165 | 0.101762389748406 166 | 0.102852652893559 167 | 0.102852652893559 168 | 0.101762389748406 169 | 0.099593420586795 170 | 0.096368737174644 171 | 0.092122522237786 172 | 0.086899787201083 173 | 0.080755895229420 174 | 0.073755974737705 175 | 0.065974229882181 176 | 0.057493156217619 177 | 0.048402672830594 178 | 0.038799192569627 179 | 0.028784707883323 180 | 0.018466468311091 181 | 0.007968192496167]'; 182 | 183 | xp=[-0.996893484074650 184 | -0.983668123279747 185 | -0.960021864968308 186 | -0.926200047429274 187 | -0.882560535792053 188 | -0.829565762382768 189 | -0.767777432104826 190 | -0.697850494793316 191 | -0.620526182989243 192 | -0.536624148142020 193 | -0.447033769538089 194 | -0.352704725530878 195 | -0.254636926167890 196 | -0.153869913608583 197 | -0.051471842555318 198 | 0.051471842555318 199 | 0.153869913608583 200 | 0.254636926167890 201 | 0.352704725530878 202 | 0.447033769538089 203 | 0.536624148142020 204 | 0.620526182989243 205 | 0.697850494793316 206 | 0.767777432104826 207 | 0.829565762382768 208 | 0.882560535792053 209 | 0.926200047429274 210 | 0.960021864968308 211 | 0.983668123279747 212 | 0.996893484074650]'; 213 | 214 | else 215 | fprintf('\n Gauss points and weights for polynomials of order 20\n or higher are not implemented yet \n') 216 | end 217 | 218 | n = length(xp); 219 | 220 | if nargin ==3 221 | wp = (b-a)/2*wp; 222 | xp = (b-a)/2*xp + (b+a)/2*ones(1,n); 223 | end 224 | 225 | -------------------------------------------------------------------------------- /examples/ALVA_let_validation3.m: -------------------------------------------------------------------------------- 1 | % DESCRIPTION: 2 | % This script tests the implementation of the acclerated ALVA LET model, 3 | % calculating the surface displacements with length for a multilayered 4 | % pavement subjected to two circular loads utilizing the method proposed in 5 | % (Andersen, Levenberg, & Andersen, 2020). The results are compared to the 6 | % computer programme ELLEA1. 7 | % ------------------------------------------------------------------------- 8 | % References 9 | % ------------------------------------------------------------------------- 10 | % Andersen, S., Levenberg, E., & Andersen, M. B (2020). Efficient 11 | % reevaluation of surface displacements in a layered elastic half-space. 12 | % The International Journal of Pavement Engineering 21(4), 1-8. 13 | % https://doi.org/10.1080/10298436.2018.1483502 14 | % 15 | % Levenberg, E. (2016a). ELLEA1: Isotropic layered elasticity in excel: 16 | % Pavement analysis tool for students and engineers. 17 | 18 | clear all, close all, clc 19 | 20 | % ------------------------------------------------------------------------- 21 | % Select response analysis type 22 | % ------------------------------------------------------------------------- 23 | alva.analysis = 'PolFit'; 24 | % 1) 'Full' : Conventional full integration (no approximations) applied 25 | % for evaluation of displacements and stresses 26 | % 2) 'PolFit': Use polynomial fit technique to reduce integral length 27 | % according to Andersen et al. (2018) for evaluation of 28 | % surface displacements 29 | 30 | % ------------------------------------------------------------------------- 31 | % Select interface 32 | % ------------------------------------------------------------------------- 33 | alva.bond = 'Bonded'; 34 | % 1) 'Bonded' : Full bonding between layers 35 | % 2) 'Slip' : Interface bonding factor 36 | % 3) 'Frictionless' : No bonding between layers 37 | 38 | % ------------------------------------------------------------------------- 39 | % Numerical parameters* 40 | % ------------------------------------------------------------------------- 41 | alva.N = 30; % Number of Bessel zero points in numerical integration 42 | alva.n = 15; % Number of Gauss points points between zero points. 43 | 44 | % *Note: These should be small compared to conventional analysis to save 45 | % computational time 46 | 47 | % ------------------------------------------------------------------------- 48 | % Pavement material properties (minimum two layers required) 49 | % ------------------------------------------------------------------------- 50 | alva.zi = [150 750]; % Depth of first n-1 layers from the surface 51 | % [mm]: last z = inf, and should not be added. 52 | % NB: zi(i) > zi(i-1) > z(i-2) ... 53 | alva.E = [3000 200 40]; % Layer Young's moduli [MPa] 54 | alva.nu = [0.30 0.35 0.4]; % Layer Poisson's ratio [-] 55 | alva.kh = [1e9 1e9]; % Interface bonding/horizontal spring [MPa/mm] 56 | 57 | % ------------------------------------------------------------------------- 58 | % Load configuration 59 | % ------------------------------------------------------------------------- 60 | alva.q = [1.1 61 | 1.1]; % Load pressure [MPa] (uniform vertical pressure) 62 | alva.a = [150 63 | 150]; % Load radii [mm] (circular load) 64 | alva.Xl = [0.0 -150 65 | 0.0 150]; % Load positions [mm]: [x1 y1; x2 y2;..xi yi]; 66 | 67 | % ------------------------------------------------------------------------- 68 | % Location of evaluation points: [x1 y1 z1; x2 y2 z2;..] 69 | % ------------------------------------------------------------------------- 70 | alva.Xd = [0 0 0; 50 0 0; 75 0 0; 100 0 0; 150 0 0; 71 | 200 0 0; 250 0 0; 300 0 0; 350 0 0; 400 0 0; 72 | 450 0 0; 500 0 0; 750 0 0; 1000 0 0; 1500 0 0; 73 | 2000 0 0; 3000 0 0]; 74 | 75 | % ------------------------------------------------------------------------- 76 | % Initialize system and get response 77 | % ------------------------------------------------------------------------- 78 | 79 | alva = init_LET(alva); 80 | 81 | % Displacements 82 | ux = alva.ux; % [mm] 83 | uy = alva.uy; % [mm] 84 | uz = alva.uz; % [mm] 85 | 86 | % ------------------------------------------------------------------------- 87 | % Validation 88 | % ------------------------------------------------------------------------- 89 | 90 | % Validation using independent software 91 | alva.validation = 'duallength'; % select dual wheel load and 92 | % displacements along x-axis at 93 | % surface 94 | ellea = validation_let(alva); % Collumns: [length/depth,sigx 95 | % ,sigy,sigx,sigzy,sigzx,sigxy,ux, 96 | % uy,uz] 97 | % ------------------------------------------------------------------------- 98 | % Plotting 99 | % ------------------------------------------------------------------------- 100 | 101 | subplot(2,1,1), title('x-axis displacement (y=z=0)'); 102 | hold on, grid on 103 | plot(alva.Xd(:,1),ux,':ks','LineWidth',1.25,'MarkerSize',5) 104 | hold on 105 | plot(ellea(:,1),ellea(:,8),':b+','LineWidth',1,'MarkerSize',5) 106 | hold on 107 | set(gca,'FontSize',9) 108 | legend({'ALVA','ELLEA1'},'Location','SouthEast') 109 | axis ij 110 | xlabel('Distance from load, x-axis [mm]') 111 | ylabel('Displacement, u_{x} [mm]') 112 | hold on 113 | 114 | subplot(2,1,2), title('z-axis displacement (y=z=0)'); 115 | hold on, grid on 116 | plot(alva.Xd(:,1),uz,':ks','LineWidth',1.25,'MarkerSize',5) 117 | hold on 118 | plot(ellea(:,1),ellea(:,10),':b+','LineWidth',1,'MarkerSize',5) 119 | hold on 120 | set(gca,'FontSize',9) 121 | legend({'ALVA','ELLEA1'},'Location','SouthEast') 122 | axis ij 123 | xlabel('Distance from load, x-axis [mm]') 124 | ylabel('Displacement, u_{z} [mm]') 125 | hold off 126 | -------------------------------------------------------------------------------- /examples/ALVA_let_validation4.m: -------------------------------------------------------------------------------- 1 | % DESCRIPTION: 2 | % This script tests the implementation of the ALVA LET model calculating 3 | % shear stresses with depth for a half-space subjected to a single circular 4 | % load. The results are compared to the computer programme ELLEA1. 5 | % ------------------------------------------------------------------------- 6 | % References 7 | % ------------------------------------------------------------------------- 8 | % Levenberg, E. (2016a). ELLEA1: Isotropic layered elasticity in excel: 9 | % Pavement analysis tool for students and engineers. 10 | 11 | clear all, close all, clc 12 | % ------------------------------------------------------------------------- 13 | % Select response analysis type 14 | % ------------------------------------------------------------------------- 15 | alva.analysis = 'Full'; 16 | % 1) 'Full' : Conventional full integration with one-step Richardson 17 | % extrapolation (for improved convergence near surface) 18 | % applied for evaluation of displacements and stresses 19 | % 2) 'PolFit' : Use polynomial fit technique to reduce integral length 20 | % according to Andersen et al. (2018) for evaluation of 21 | % surface displacements 22 | 23 | % ------------------------------------------------------------------------- 24 | % Select interface 25 | % ------------------------------------------------------------------------- 26 | alva.bond = 'Bonded'; 27 | % 1) 'Bonded' : Full bonding between layers 28 | % 2) 'Slip' : Interface bonding factor 29 | % 3) 'Frictionless' : No bonding between layers 30 | 31 | % ------------------------------------------------------------------------- 32 | % Numerical parameters 33 | % ------------------------------------------------------------------------- 34 | alva.N = 300; % Number of Bessel zero points in numerical integration 35 | alva.n = 30; % Number of Gauss points points between zero points. 36 | 37 | % ------------------------------------------------------------------------- 38 | % Pavement material properties (minimum two layers required) 39 | % ------------------------------------------------------------------------- 40 | alva.zi = [150 750]; % Depth of first n-1 layers from the 41 | % surface [mm]: last z = inf, and should not 42 | % be added NB: zi(i) > zi(i-1) > z(i-2)... 43 | alva.E = [200 200 200]; % Layer Young's moduli [MPa] 44 | alva.nu = [0.35 0.35 0.35]; % Layer Poisson's ratio [-] 45 | alva.kh = [1e9 1e9]; % Interface bonding/horizontal spring [MPa/mm] 46 | 47 | % ------------------------------------------------------------------------- 48 | % Load configuration 49 | % ------------------------------------------------------------------------- 50 | alva.q = 1.1; % Load pressure [MPa] (uniform vertical pressure) 51 | alva.a = 150; % Load radii [mm] (circular load) 52 | alva.Xl = [0 0]; % Load positions [mm]: [x1 y1; x2 y2;..xi yi]; 53 | 54 | % ------------------------------------------------------------------------- 55 | % Location of evaluation points: [x1 y1 z1; x2 y2 z2;..] 56 | % ------------------------------------------------------------------------- 57 | alva.Xd = [10 20 0; 10 20 10; 10 20 20; 58 | 10 20 30; 10 20 40; 10 20 50; 59 | 10 20 75; 10 20 100; 10 20 150; 60 | 10 20 200; 10 20 250; 10 20 300; 61 | 10 20 350; 10 20 400; 10 20 450; 62 | 10 20 500; 10 20 750; 10 20 1000]; 63 | 64 | % ------------------------------------------------------------------------- 65 | % Initialize system and get response 66 | % ------------------------------------------------------------------------- 67 | alva = init_LET(alva); 68 | 69 | % Displacements 70 | ux = alva.ux; 71 | uy = alva.uy; % [mm] 72 | uz = alva.uz; % [mm] 73 | 74 | % Stresses 75 | sigx = alva.sigx; % [MPa] 76 | sigy = alva.sigy; % [MPa] 77 | sigz = alva.sigz; % [MPa] 78 | sigxy = alva.sigxy; % [MPa] 79 | sigyz = alva.sigyz; % [MPa] 80 | sigxz = alva.sigxz; % [MPa] 81 | 82 | % Strains 83 | epsx = alva.epsx.*1e6; % [micro strain] 84 | epsy = alva.epsy.*1e6; % [micro strain] 85 | epsz = alva.epsz.*1e6; % [micro strain] 86 | epsxy = alva.epsxy.*1e6; % [micro strain] 87 | epsyz = alva.epsyz.*1e6; % [micro strain] 88 | epsxz = alva.epsxz.*1e6; % [micro strain] 89 | 90 | % ------------------------------------------------------------------------- 91 | % Validation 92 | % ------------------------------------------------------------------------- 93 | 94 | % Validation using independent software 95 | alva.validation = 'halfspace_shear'; % select dual wheel load and 96 | % shear stresses with depth 97 | ellea = validation_let(alva); % Collumns: [length/depth,sigx 98 | % ,sigy,sigx,sigzy,sigzx,sigxy,ux, 99 | % uy,uz] 100 | 101 | % ------------------------------------------------------------------------- 102 | % Plotting 103 | % ------------------------------------------------------------------------- 104 | 105 | figure, title('Shear stress (x=10, y=20)'); 106 | hold on, grid on 107 | plot(sigxy,alva.Xd(:,3),':ks','LineWidth',1.25,'MarkerSize',5) 108 | hold on 109 | plot(sigyz,alva.Xd(:,3),':ko','LineWidth',1.25,'MarkerSize',5) 110 | hold on 111 | plot(sigxz,alva.Xd(:,3),':k^','LineWidth',1.25,'MarkerSize',5) 112 | hold on 113 | plot(ellea(:,7),ellea(:,1),':b+','LineWidth',1,'MarkerSize',5) 114 | hold on 115 | plot(ellea(:,5),ellea(:,1),':g+','LineWidth',1,'MarkerSize',5) 116 | hold on 117 | plot(ellea(:,6),ellea(:,1),':r+','LineWidth',1,'MarkerSize',5) 118 | hold on 119 | set(gca,'FontSize',9) 120 | legend({'ALVA - sigxy','ALVA - sigyz','ALVA - sigxz',... 121 | 'ELLEA1 - sigxy','ELLEA1 - sigyz','ELLEA1 - sigxz'},... 122 | 'Location','SouthEast') 123 | axis ij 124 | xlabel('Stress, \sigma [MPa]') 125 | ylabel('Depth, z-axis [mm]') 126 | hold off 127 | -------------------------------------------------------------------------------- /examples/ALVA_let_validation5.m: -------------------------------------------------------------------------------- 1 | % DESCRIPTION: 2 | % This script tests the implementation of the ALVA LET model, calculating 3 | % strains with depth for a multilayered pavement subjected to two circular 4 | % loads utilizing the method proposed. The results are compared to the 5 | % computer programme ELLEA1. 6 | % ------------------------------------------------------------------------- 7 | % References 8 | % ------------------------------------------------------------------------- 9 | % Levenberg, E. (2016a). ELLEA1: Isotropic layered elasticity in excel: 10 | % Pavement analysis tool for students and engineers. 11 | 12 | clear all, close all, clc 13 | % ------------------------------------------------------------------------- 14 | % Select response analysis type 15 | % ------------------------------------------------------------------------- 16 | alva.analysis = 'Full'; 17 | % 1) 'Full' : Conventional full integration with one-step Richardson 18 | % extrapolation (for improved convergence near surface) 19 | % applied for evaluation of displacements and stresses 20 | % 2) 'PolFit' : Use polynomial fit technique to reduce integral length 21 | % according to Andersen et al. (2018) for evaluation of 22 | % surface displacements 23 | 24 | % ------------------------------------------------------------------------- 25 | % Select interface 26 | % ------------------------------------------------------------------------- 27 | alva.bond = 'Bonded'; 28 | % 1) 'Bonded' : Full bonding between layers 29 | % 2) 'Slip' : Interface bonding factor 30 | % 3) 'Frictionless' : No bonding between layers 31 | 32 | % ------------------------------------------------------------------------- 33 | % Numerical parameters 34 | % ------------------------------------------------------------------------- 35 | alva.N = 300; % Number of Bessel zero points in numerical integration 36 | alva.n = 30; % Number of Gauss points points between zero points. 37 | 38 | % ------------------------------------------------------------------------- 39 | % Pavement material properties (minimum two layers required) 40 | % ------------------------------------------------------------------------- 41 | alva.zi = [150 750]; % Depth of first n-1 layers from the 42 | % surface [mm]: last z = inf, and should not 43 | % be added NB: zi(i) > zi(i-1) > z(i-2)... 44 | alva.E = [3000 200 40]; % Layer Young's moduli [MPa] 45 | alva.nu = [0.30 0.35 0.40]; % Layer Poisson's ratio [-] 46 | alva.kh = [1e9 1e9]; % Interface bonding/horizontal spring [MPa/mm] 47 | 48 | % ------------------------------------------------------------------------- 49 | % Load configuration 50 | % ------------------------------------------------------------------------- 51 | alva.q = [1.1 52 | 1.1]; % Load pressure [MPa] (uniform vertical pressure) 53 | alva.a = [150 54 | 150]; % Load radii [mm] (circular load) 55 | alva.Xl = [0.0 -150 56 | 0.0 150]; % Load positions [mm]: [x1 y1; x2 y2;..xi yi]; 57 | 58 | % ------------------------------------------------------------------------- 59 | % Location of evaluation points: [x1 y1 z1; x2 y2 z2;..] 60 | % ------------------------------------------------------------------------- 61 | alva.Xd = [10 20 0; 10 20 10; 10 20 20; 62 | 10 20 30; 10 20 40; 10 20 50; 63 | 10 20 75; 10 20 100; 10 20 150; 64 | 10 20 200; 10 20 250; 10 20 300; 65 | 10 20 350; 10 20 400; 10 20 450; 66 | 10 20 500; 10 20 750; 10 20 1000]; 67 | 68 | % ------------------------------------------------------------------------- 69 | % Initialize system and get response 70 | % ------------------------------------------------------------------------- 71 | alva = init_LET(alva); 72 | 73 | % Displacements 74 | ux = alva.ux; 75 | uy = alva.uy; % [mm] 76 | uz = alva.uz; % [mm] 77 | 78 | % Stresses 79 | sigx = alva.sigx; % [MPa] 80 | sigy = alva.sigy; % [MPa] 81 | sigz = alva.sigz; % [MPa] 82 | sigxy = alva.sigxy; % [MPa] 83 | sigyz = alva.sigyz; % [MPa] 84 | sigxz = alva.sigxz; % [MPa] 85 | 86 | % Strains 87 | epsx = alva.epsx.*1e6; % [micro strain] 88 | epsy = alva.epsy.*1e6; % [micro strain] 89 | epsz = alva.epsz.*1e6; % [micro strain] 90 | epsxy = alva.epsxy.*1e6; % [micro strain] 91 | epsyz = alva.epsyz.*1e6; % [micro strain] 92 | epsxz = alva.epsxz.*1e6; % [micro strain] 93 | 94 | % ------------------------------------------------------------------------- 95 | % Validation 96 | % ------------------------------------------------------------------------- 97 | 98 | % Validation using independent software 99 | alva.validation = 'halfspace_shear_strain'; % select dual wheel load and 100 | % shear stresses with depth 101 | ellea = validation_let(alva); % Collumns: [length/depth,epsx 102 | % ,epsy,epsx,epsxy,epszy,epszx] 103 | 104 | % ------------------------------------------------------------------------- 105 | % Plotting 106 | % ------------------------------------------------------------------------- 107 | 108 | figure, title('Shear strain (x=10, y=20)'); 109 | hold on, grid on 110 | plot(epsxy,alva.Xd(:,3),':ks','LineWidth',1.25,'MarkerSize',5) 111 | hold on 112 | plot(epsyz,alva.Xd(:,3),':ko','LineWidth',1.25,'MarkerSize',5) 113 | hold on 114 | plot(epsxz,alva.Xd(:,3),':k^','LineWidth',1.25,'MarkerSize',5) 115 | hold on 116 | plot(ellea(:,5),ellea(:,1),':b+','LineWidth',1,'MarkerSize',5) 117 | hold on 118 | plot(ellea(:,6),ellea(:,1),':g+','LineWidth',1,'MarkerSize',5) 119 | hold on 120 | plot(ellea(:,7),ellea(:,1),':r+','LineWidth',1,'MarkerSize',5) 121 | hold on 122 | set(gca,'FontSize',9) 123 | legend({'ALVA - epsxy','ALVA - epsyz','ALVA - epsxz',... 124 | 'ELLEA1 - epsxy','ELLEA1 - epsyz','ELLEA1 - epsxz'},... 125 | 'Location','SouthEast') 126 | axis ij 127 | xlabel('Strain, \epsilon [-]') 128 | ylabel('Depth, z-axis [mm]') 129 | hold off 130 | -------------------------------------------------------------------------------- /validation/validation_ve.m: -------------------------------------------------------------------------------- 1 | function deylev = validation_ve 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function looks up caluclated response for different validation 5 | % cases using the computer program ELLVA_VD [1] 6 | % ------------------------------------------------------------------------- 7 | % References 8 | % ------------------------------------------------------------------------- 9 | %[1] Levenberg, E. (2018). ELLVA_VD: Isotropic Layered Viscoelasticity in 10 | % Excel: Analysis tool for interpretation of deflections measured with a 11 | % moving load 12 | 13 | %------------------------------------------------------------------------- 14 | % 1:position 2:time 3:uz 15 | %------------------------------------------------------------------------- 16 | 17 | deylev=[-5000.0 0.000 1.06E-01 18 | -4950.0 0.003 1.06E-01 19 | -4900.0 0.006 1.07E-01 20 | -4850.0 0.009 1.08E-01 21 | -4800.0 0.012 1.10E-01 22 | -4750.0 0.015 1.11E-01 23 | -4700.0 0.018 1.12E-01 24 | -4650.0 0.021 1.14E-01 25 | -4600.0 0.024 1.15E-01 26 | -4550.0 0.027 1.16E-01 27 | -4500.0 0.030 1.18E-01 28 | -4450.0 0.033 1.19E-01 29 | -4400.0 0.036 1.21E-01 30 | -4350.0 0.039 1.22E-01 31 | -4300.0 0.042 1.24E-01 32 | -4250.0 0.045 1.25E-01 33 | -4200.0 0.048 1.27E-01 34 | -4150.0 0.051 1.28E-01 35 | -4100.0 0.054 1.30E-01 36 | -4050.0 0.057 1.32E-01 37 | -4000.0 0.060 1.33E-01 38 | -3950.0 0.063 1.35E-01 39 | -3900.0 0.066 1.37E-01 40 | -3850.0 0.069 1.39E-01 41 | -3800.0 0.072 1.41E-01 42 | -3750.0 0.075 1.43E-01 43 | -3700.0 0.078 1.45E-01 44 | -3650.0 0.081 1.47E-01 45 | -3600.0 0.084 1.50E-01 46 | -3550.0 0.087 1.52E-01 47 | -3500.0 0.090 1.54E-01 48 | -3450.0 0.093 1.57E-01 49 | -3400.0 0.096 1.59E-01 50 | -3350.0 0.099 1.62E-01 51 | -3300.0 0.102 1.64E-01 52 | -3250.0 0.105 1.67E-01 53 | -3200.0 0.108 1.70E-01 54 | -3150.0 0.111 1.73E-01 55 | -3100.0 0.114 1.76E-01 56 | -3050.0 0.117 1.79E-01 57 | -3000.0 0.120 1.82E-01 58 | -2950.0 0.123 1.85E-01 59 | -2900.0 0.126 1.89E-01 60 | -2850.0 0.129 1.92E-01 61 | -2800.0 0.132 1.96E-01 62 | -2750.0 0.135 1.99E-01 63 | -2700.0 0.138 2.03E-01 64 | -2650.0 0.141 2.07E-01 65 | -2600.0 0.144 2.11E-01 66 | -2550.0 0.147 2.15E-01 67 | -2500.0 0.150 2.19E-01 68 | -2450.0 0.153 2.24E-01 69 | -2400.0 0.156 2.28E-01 70 | -2350.0 0.159 2.33E-01 71 | -2300.0 0.162 2.38E-01 72 | -2250.0 0.165 2.43E-01 73 | -2200.0 0.168 2.48E-01 74 | -2150.0 0.171 2.54E-01 75 | -2100.0 0.174 2.59E-01 76 | -2050.0 0.177 2.65E-01 77 | -2000.0 0.180 2.71E-01 78 | -1950.0 0.183 2.77E-01 79 | -1900.0 0.186 2.83E-01 80 | -1850.0 0.189 2.90E-01 81 | -1800.0 0.192 2.97E-01 82 | -1750.0 0.195 3.04E-01 83 | -1700.0 0.198 3.11E-01 84 | -1650.0 0.201 3.19E-01 85 | -1600.0 0.204 3.27E-01 86 | -1550.0 0.207 3.35E-01 87 | -1500.0 0.210 3.43E-01 88 | -1450.0 0.213 3.52E-01 89 | -1400.0 0.216 3.61E-01 90 | -1350.0 0.219 3.70E-01 91 | -1300.0 0.222 3.80E-01 92 | -1250.0 0.225 3.90E-01 93 | -1200.0 0.228 4.01E-01 94 | -1150.0 0.231 4.12E-01 95 | -1100.0 0.234 4.23E-01 96 | -1050.0 0.237 4.35E-01 97 | -1000.0 0.240 4.47E-01 98 | -950.0 0.243 4.60E-01 99 | -900.0 0.246 4.74E-01 100 | -850.0 0.249 4.88E-01 101 | -800.0 0.252 5.02E-01 102 | -750.0 0.255 5.18E-01 103 | -700.0 0.258 5.34E-01 104 | -650.0 0.261 5.50E-01 105 | -600.0 0.264 5.68E-01 106 | -550.0 0.267 5.86E-01 107 | -500.0 0.270 6.05E-01 108 | -450.0 0.273 6.25E-01 109 | -400.0 0.276 6.45E-01 110 | -350.0 0.279 6.66E-01 111 | -300.0 0.282 6.87E-01 112 | -250.0 0.285 7.07E-01 113 | -200.0 0.288 7.28E-01 114 | -150.0 0.291 7.46E-01 115 | -100.0 0.294 7.63E-01 116 | -50.0 0.297 7.77E-01 117 | 0.0 0.300 7.86E-01 118 | 50.0 0.303 7.91E-01 119 | 100.0 0.306 7.90E-01 120 | 150.0 0.309 7.84E-01 121 | 200.0 0.312 7.74E-01 122 | 250.0 0.315 7.60E-01 123 | 300.0 0.318 7.42E-01 124 | 350.0 0.321 7.23E-01 125 | 400.0 0.324 7.02E-01 126 | 450.0 0.327 6.80E-01 127 | 500.0 0.330 6.58E-01 128 | 550.0 0.333 6.37E-01 129 | 600.0 0.336 6.15E-01 130 | 650.0 0.339 5.95E-01 131 | 700.0 0.342 5.75E-01 132 | 750.0 0.345 5.56E-01 133 | 800.0 0.348 5.38E-01 134 | 850.0 0.351 5.21E-01 135 | 900.0 0.354 5.04E-01 136 | 950.0 0.357 4.89E-01 137 | 1000.0 0.360 4.74E-01 138 | 1050.0 0.363 4.60E-01 139 | 1100.0 0.366 4.47E-01 140 | 1150.0 0.369 4.34E-01 141 | 1200.0 0.372 4.22E-01 142 | 1250.0 0.375 4.11E-01 143 | 1300.0 0.378 4.00E-01 144 | 1350.0 0.381 3.89E-01 145 | 1400.0 0.384 3.79E-01 146 | 1450.0 0.387 3.70E-01 147 | 1500.0 0.390 3.60E-01 148 | 1550.0 0.393 3.51E-01 149 | 1600.0 0.396 3.43E-01 150 | 1650.0 0.399 3.34E-01 151 | 1700.0 0.402 3.26E-01 152 | 1750.0 0.405 3.19E-01 153 | 1800.0 0.408 3.11E-01 154 | 1850.0 0.411 3.04E-01 155 | 1900.0 0.414 2.97E-01 156 | 1950.0 0.417 2.90E-01 157 | 2000.0 0.420 2.84E-01 158 | 2050.0 0.423 2.78E-01 159 | 2100.0 0.426 2.72E-01 160 | 2150.0 0.429 2.66E-01 161 | 2200.0 0.432 2.60E-01 162 | 2250.0 0.435 2.54E-01 163 | 2300.0 0.438 2.49E-01 164 | 2350.0 0.441 2.44E-01 165 | 2400.0 0.444 2.39E-01 166 | 2450.0 0.447 2.34E-01 167 | 2500.0 0.450 2.29E-01 168 | 2550.0 0.453 2.25E-01 169 | 2600.0 0.456 2.21E-01 170 | 2650.0 0.459 2.16E-01 171 | 2700.0 0.462 2.12E-01 172 | 2750.0 0.465 2.08E-01 173 | 2800.0 0.468 2.04E-01 174 | 2850.0 0.471 2.01E-01 175 | 2900.0 0.474 1.97E-01 176 | 2950.0 0.477 1.94E-01 177 | 3000.0 0.480 1.90E-01 178 | 3050.0 0.483 1.87E-01 179 | 3100.0 0.486 1.84E-01 180 | 3150.0 0.489 1.81E-01 181 | 3200.0 0.492 1.77E-01 182 | 3250.0 0.495 1.75E-01 183 | 3300.0 0.498 1.72E-01 184 | 3350.0 0.501 1.69E-01 185 | 3400.0 0.504 1.66E-01 186 | 3450.0 0.507 1.64E-01 187 | 3500.0 0.510 1.61E-01 188 | 3550.0 0.513 1.58E-01 189 | 3600.0 0.516 1.56E-01 190 | 3650.0 0.519 1.54E-01 191 | 3700.0 0.522 1.51E-01 192 | 3750.0 0.525 1.49E-01 193 | 3800.0 0.528 1.47E-01 194 | 3850.0 0.531 1.45E-01 195 | 3900.0 0.534 1.43E-01 196 | 3950.0 0.537 1.41E-01 197 | 4000.0 0.540 1.39E-01 198 | 4050.0 0.543 1.37E-01 199 | 4100.0 0.546 1.36E-01 200 | 4150.0 0.549 1.34E-01 201 | 4200.0 0.552 1.32E-01 202 | 4250.0 0.555 1.30E-01 203 | 4300.0 0.558 1.29E-01 204 | 4350.0 0.561 1.27E-01 205 | 4400.0 0.564 1.26E-01 206 | 4450.0 0.567 1.24E-01 207 | 4500.0 0.570 1.23E-01 208 | 4550.0 0.573 1.21E-01 209 | 4600.0 0.576 1.20E-01 210 | 4650.0 0.579 1.19E-01 211 | 4700.0 0.582 1.17E-01 212 | 4750.0 0.585 1.16E-01 213 | 4800.0 0.588 1.14E-01 214 | 4850.0 0.591 1.13E-01 215 | 4900.0 0.594 1.12E-01 216 | 4950.0 0.597 1.10E-01 217 | 5000.0 0.600 1.09E-01]; -------------------------------------------------------------------------------- /examples/ALVA_let_validation1.m: -------------------------------------------------------------------------------- 1 | % DESCRIPTION: 2 | % This script tests the implementation of the ALVA LET model calculating 3 | % vertical stresses and displacements with depth for a half-space subjected 4 | % to a single circular load. 5 | % The results are compared to the analytical Boussinesq solution and the 6 | % computer programme ELLEA1. 7 | % ------------------------------------------------------------------------- 8 | % References 9 | % ------------------------------------------------------------------------- 10 | % Levenberg, E. (2016). ELLEA1: Isotropic Layered Elasticity in Excel: 11 | % Pavement analysis tool for students and engineers 12 | 13 | clear all, close all, clc 14 | 15 | % ------------------------------------------------------------------------- 16 | % Select response analysis type 17 | % ------------------------------------------------------------------------- 18 | alva.analysis = 'Full'; 19 | % 1) 'Full' : Conventional full integration with one-step Richardson 20 | % extrapolation (for improved convergence near surface) 21 | % applied for evaluation of displacements and stresses 22 | % 2) 'PolFit' : Use polynomial fit technique to reduce integral length 23 | % according to Andersen et al. (2018) for evaluation of 24 | % surface displacements 25 | 26 | % ------------------------------------------------------------------------- 27 | % Select interface 28 | % ------------------------------------------------------------------------- 29 | alva.bond = 'Bonded'; 30 | % 1) 'Bonded' : Full bonding between layers 31 | % 2) 'Slip' : Interface bonding factor 32 | % 3) 'Frictionless' : No bonding between layers 33 | 34 | % ------------------------------------------------------------------------- 35 | % Numerical parameters 36 | % ------------------------------------------------------------------------- 37 | alva.N = 300; % Number of Bessel zero points in numerical integration 38 | alva.n = 30; % Number of Gauss points points between zero points. 39 | 40 | % ------------------------------------------------------------------------- 41 | % Pavement material properties (minimum two layers required) 42 | % ------------------------------------------------------------------------- 43 | alva.zi = [150 750]; % Depth of first n-1 layers from the 44 | % surface [mm]: last z = inf, and should not 45 | % be added NB: zi(i) > zi(i-1) > z(i-2)... 46 | alva.E = [200 200 200]; % Layer Young's moduli [MPa] 47 | alva.nu = [0.35 0.35 0.35]; % Layer Poisson's ratio [-] 48 | alva.kh = [1e9 1e9]; % Interface bonding/horizontal spring [MPa/mm] 49 | 50 | % ------------------------------------------------------------------------- 51 | % Load configuration 52 | % ------------------------------------------------------------------------- 53 | alva.q = 1.1; % Load pressure [MPa] (uniform vertical pressure) 54 | alva.a = 150; % Load radii [mm] (circular load) 55 | alva.Xl = [0 0]; % Load positions [mm]: [x1 y1; x2 y2;..xi yi]; 56 | 57 | % ------------------------------------------------------------------------- 58 | % Location of evaluation points: [x1 y1 z1; x2 y2 z2;..] in [mm] 59 | % ------------------------------------------------------------------------- 60 | alva.Xd = [0 0 0; 0 0 10; 0 0 20; 61 | 0 0 30; 0 0 40; 0 0 50; 62 | 0 0 75; 0 0 100; 0 0 150; 63 | 0 0 200; 0 0 250; 0 0 300; 64 | 0 0 350; 0 0 400; 0 0 450; 65 | 0 0 500; 0 0 750; 0 0 1000]; 66 | % ------------------------------------------------------------------------- 67 | % Initialize system and get response 68 | % ------------------------------------------------------------------------- 69 | 70 | alva = init_LET(alva); 71 | 72 | % Displacements 73 | ux = alva.ux; 74 | uy = alva.uy; % [mm] 75 | uz = alva.uz; % [mm] 76 | 77 | % Stresses 78 | sigx = alva.sigx; % [MPa] 79 | sigy = alva.sigy; % [MPa] 80 | sigz = alva.sigz; % [MPa] 81 | sigxy = alva.sigxy; % [MPa] 82 | sigyz = alva.sigyz; % [MPa] 83 | sigxz = alva.sigxz; % [MPa] 84 | 85 | % Strains 86 | epsx = alva.epsx.*1e6; % [micro strain] 87 | epsy = alva.epsy.*1e6; % [micro strain] 88 | epsz = alva.epsz.*1e6; % [micro strain] 89 | epsxy = alva.epsxy.*1e6; % [micro strain] 90 | epsyz = alva.epsyz.*1e6; % [micro strain] 91 | epsxz = alva.epsxz.*1e6; % [micro strain] 92 | 93 | % ------------------------------------------------------------------------- 94 | % Validation 95 | % ------------------------------------------------------------------------- 96 | % Validation using analytical solution 97 | boussinesq = validation_boussinesq(alva); % Collumns: [sigz,uz] 98 | 99 | % Validation using independent software 100 | alva.validation = 'halfspace'; % select half-space solution 101 | ellea = validation_let(alva); % Collumns: [length/depth,sigx 102 | % ,sigy,sigx,sigzy,sigzx,sigxy,ux, 103 | % uy,uz] 104 | % ------------------------------------------------------------------------- 105 | % Plotting 106 | % ------------------------------------------------------------------------- 107 | 108 | subplot(1,2,1), title('z-axis displacement (x=y=0)'); 109 | hold on, grid on 110 | plot(uz,alva.Xd(:,3),':ks','LineWidth',1.25,'MarkerSize',5) 111 | hold on, grid on 112 | plot(ellea(:,10),ellea(:,1),':b+','LineWidth',1,'MarkerSize',5) 113 | hold on 114 | plot(boussinesq(:,2),alva.Xd(:,3),'-.r','LineWidth',1,'MarkerSize',5) 115 | hold on 116 | set(gca,'FontSize',9) 117 | legend({'ALVA','ELLEA1','Analytical'},... 118 | 'Location','SouthEast') 119 | axis ij 120 | xlabel('Displacement, u_{z} [mm]') 121 | ylabel('Depth, z-axis [mm]') 122 | hold on 123 | 124 | subplot(1,2,2), title('z-axis stress (x=y=0)'); 125 | hold on, grid on 126 | plot(sigz,alva.Xd(:,3),':ks','LineWidth',1.25,'MarkerSize',5) 127 | hold on 128 | plot(ellea(:,4),ellea(:,1),':b+','LineWidth',1,'MarkerSize',5) 129 | hold on 130 | plot(boussinesq(:,1),alva.Xd(:,3),'-.r','LineWidth',1,'MarkerSize',5) 131 | hold on 132 | set(gca,'FontSize',9) 133 | legend({'ALVA','ELLEA1','Analytical'},... 134 | 'Location','SouthEast') 135 | axis ij 136 | xlabel('Stress, \sigma_{z} [MPa]') 137 | ylabel('Depth, z-axis [mm]') 138 | hold off 139 | -------------------------------------------------------------------------------- /examples/ALVA_visco_validation1.m: -------------------------------------------------------------------------------- 1 | % DESCRIPTION: 2 | % This script tests the implementation of the ALVA VE model, calculating 3 | % the displacements for a single evaluation point on the surface of 4 | % a multilayered pavement considering a single circular load. The results 5 | % are compared to the computer programme ELLVA1, see details in 6 | % (Levenberg, 2016c). 7 | % ------------------------------------------------------------------------- 8 | % References 9 | % ------------------------------------------------------------------------- 10 | % Levenberg, E. (2016b). ELLVA1: Isotropic layered viscoelasticity in 11 | % excel (moving load): Advanced pavement analysis tool for students and 12 | % engineers. 13 | % 14 | % Levenberg, E. (2016c). Viscoelastic pavement modeling with a 15 | % spreadsheet. Proceedings of the Eighth International Conference on 16 | % Maintenance and Rehabilitation of Pavements (mairepav8), 746–755. 17 | % doi:10.3850/978-981-11-0449-7-132-cd 18 | 19 | clear all, close all, clc 20 | % ------------------------------------------------------------------------- 21 | % Select response analysis type 22 | % ------------------------------------------------------------------------- 23 | alva.analysis = 'Full'; 24 | % 1) 'Full' : Conventional full integration (no approximations) applied 25 | % for evaluation of displacements and stresses 26 | % 2) 'PolFit': Use polynomial fit technique to reduce integral length 27 | % according to Andersen et al. (2018) for evaluation of 28 | % surface displacements 29 | 30 | % ------------------------------------------------------------------------- 31 | % Select interface 32 | % ------------------------------------------------------------------------- 33 | alva.bond = 'Bonded'; 34 | % 1) 'Bonded' : Full bonding between layers 35 | % 2) 'Slip' : Interface bonding factor 36 | % 3) 'Frictionless' : No bonding between layers 37 | 38 | % ------------------------------------------------------------------------- 39 | % Numerical parameters 40 | % ------------------------------------------------------------------------- 41 | alva.N = 300; % Number of Bessel zero points in numerical integration 42 | alva.n = 30; % Number of Gauss points points between zero points. 43 | 44 | % ------------------------------------------------------------------------- 45 | % Pavement material properties (minimum two layers required) 46 | % ------------------------------------------------------------------------- 47 | alva.zi = [150 750]; % Depth of first n-1 layers from the surface 48 | % [mm]: last z = inf, and should not be added. 49 | % NB: zi(i) > zi(i-1) > z(i-2) ... 50 | alva.E = [3000 200 40]; % Layer Young's moduli [MPa] 51 | alva.nu = [0.30 0.35 0.4]; % Layer Poisson's ratio [-] 52 | alva.kh = [1e9 1e9]; % Interface bonding/horizontal spring [MPa/mm] 53 | 54 | % Viscoelastic properties of asphaltlayer E(1) 55 | D0 = 2.5e-5; % Instantaneous or glassy compliance, [1/MPa] 56 | Dinf = 1.0e-2; % Long time equilibrium or rubbery compliance [1/MPa] 57 | nD = 0.35; % Slope of the creep curve in the transient region [-] 58 | tauD = 1e3; % Retardation time of the material response [s] 59 | 60 | % ------------------------------------------------------------------------- 61 | % Load configuration 62 | % ------------------------------------------------------------------------- 63 | alva.q = 1.1; % Tire pressure vector [MPa] 64 | alva.a = 150; % Load radius vector [mm] 65 | alva.Xl = [0 300]; % Load coordinates in [mm] 66 | 67 | % ------------------------------------------------------------------------- 68 | % Location of evaluation and mesh points: [x1 y1 z1; x2 y2 z2;..] 69 | % ------------------------------------------------------------------------- 70 | rep = [0 0 0]; % [x y z]-coordinate of evaluation point 71 | nels = 200; % Number of elements 72 | Vkh = 60; % Vehicle speed [km/h] 73 | V = Vkh/3.6*1e3; % Vehicle speed [mm/s] 74 | x0 = 5000; % Start / end of mesh [mm] 75 | dx0 = 2*x0/nels; % Mesh increment [mm] 76 | dt = dx0/V; alva.dt = dt; % Time increment [s] 77 | tt = 2*x0/V; alva.tt = tt; % Total travel time [s] 78 | xx = (0:dx0:x0); % Mesh x-direction 79 | yy = rep(2)*ones(length(xx),1); % Mesh y-direction 80 | zz = rep(3)*ones(length(xx),1); % Mesh z-direction 81 | Xr = [xx' yy zz]; alva.Xr = Xr; % Full mesh matrix 82 | 83 | % Knots for cubic spline interpolation 84 | kx = [0 x0^(2/16) x0^(3/16) x0^(4/16) x0^(5/16) x0^(6/16) x0^(7/16)... 85 | x0^(8/16) x0^(9/16) x0^(10/16) x0^(11/16) x0^(12/16) x0^(13/16)... 86 | x0^(14/16) x0^(15/16) x0^(16/16)]; 87 | Xd = [kx; ones(1,length(kx))*rep(2); ones(1,length(kx))*rep(3)]'; 88 | alva.Xd = Xd; 89 | 90 | % ------------------------------------------------------------------------- 91 | % Determine creep compliance curve and relaxation modulus 92 | % ------------------------------------------------------------------------- 93 | alva.ti = 12; % Number increments on compliance curve 94 | alva = VE_moduli(D0,Dinf,tauD,nD,alva); 95 | 96 | % ------------------------------------------------------------------------- 97 | % Calculate linear elastic response at different times 98 | % ------------------------------------------------------------------------- 99 | alva = VE_response(alva.E,alva); 100 | 101 | % ------------------------------------------------------------------------- 102 | % Simulate moving load 103 | % ------------------------------------------------------------------------- 104 | 105 | % Select output response: displacements (dxm, dym or dzm), stresses (sigxm, 106 | % sigym, sigzm, sigxym, sigyzm or sigxzm), strains (epsxm, epsym, epszm, 107 | % epsxym, epsyzm or epsxzm) 108 | 109 | letres = alva.dzm; % output response dz 110 | veres = VE_simulation(letres,alva); % run simulation 111 | 112 | % ------------------------------------------------------------------------- 113 | % Validation 114 | % ------------------------------------------------------------------------- 115 | 116 | % Validation using independent software 117 | ellva = validation_ve; % collumns: [position time uz] 118 | 119 | % ------------------------------------------------------------------------- 120 | % Plotting 121 | % ------------------------------------------------------------------------- 122 | figure, title('z-axis displacement vs. vehicle position (y=300 mm)'); 123 | plot((-x0:dx0:x0),veres,':k','LineWidth',1.25,'MarkerSize',6) 124 | hold on, grid on 125 | plot(ellva(:,1),ellva(:,3),'-.b','LineWidth',1.25,'MarkerSize',6) 126 | hold on, 127 | set(gca, 'FontSize',9) 128 | legend({'ALVA','ELLVA VD'},... 129 | 'Location','SouthEast') 130 | axis ij 131 | xlabel('Load position relative to evaluation point [mm]') 132 | ylabel('Displacement, u_z [mm]') 133 | hold off 134 | -------------------------------------------------------------------------------- /examples/ALVA_let_validation2.m: -------------------------------------------------------------------------------- 1 | % DESCRIPTION: 2 | % This script tests the implementation of the ALVA LET model, calculating 3 | % stresses and displacements with depth for a multilayered pavement 4 | % subjected to two circular loads utilizing the method proposed. The 5 | % results are compared to the computer programme ELLEA1. 6 | % ------------------------------------------------------------------------- 7 | % References 8 | % ------------------------------------------------------------------------- 9 | % Levenberg, E. (2016a). ELLEA1: Isotropic layered elasticity in excel: 10 | % Pavement analysis tool for students and engineers. 11 | 12 | clear all, close all, clc 13 | 14 | % ------------------------------------------------------------------------- 15 | % Select response analysis type 16 | % ------------------------------------------------------------------------- 17 | alva.analysis = 'Full'; 18 | % 1) 'Full' : Conventional full integration (no approximations) applied 19 | % for evaluation of displacements and stresses 20 | % 2) 'PolFit': Use polynomial fit technique to reduce integral length 21 | % according to Andersen et al. (2018) for evaluation of 22 | % surface displacements 23 | 24 | % ------------------------------------------------------------------------- 25 | % Select interface 26 | % ------------------------------------------------------------------------- 27 | alva.bond = 'Bonded'; 28 | % 1) 'Bonded' : Full bonding between layers 29 | % 2) 'Slip' : Interface bonding factor 30 | % 3) 'Frictionless' : No bonding between layers 31 | 32 | % ------------------------------------------------------------------------- 33 | % Numerical parameters 34 | % ------------------------------------------------------------------------- 35 | alva.N = 300; % Number of Bessel zero points in numerical integration 36 | alva.n = 30; % Number of Gauss points points between zero points. 37 | 38 | % ------------------------------------------------------------------------- 39 | % Pavement material properties (minimum two layers required) 40 | % ------------------------------------------------------------------------- 41 | alva.zi = [150 750]; % Depth of first n-1 layers from the surface 42 | % [mm]: last z = inf, and should not be added. 43 | % NB: zi(i) > zi(i-1) > z(i-2) ... 44 | alva.E = [3000 200 40]; % Layer Young's moduli [MPa] 45 | alva.nu = [0.30 0.35 0.4]; % Layer Poisson's ratio [-] 46 | alva.kh = [1e9 1e9]; % Interface bonding/horizontal spring [MPa/mm] 47 | 48 | % ------------------------------------------------------------------------- 49 | % Load configuration 50 | % ------------------------------------------------------------------------- 51 | alva.q = [1.1 52 | 1.1]; % Load pressure [MPa] (uniform vertical pressure) 53 | alva.a = [150 54 | 150]; % Load radii [mm] (circular load) 55 | alva.Xl = [0.0 -150 56 | 0.0 150]; % Load positions [mm]: [x1 y1; x2 y2;..xi yi]; 57 | 58 | % ------------------------------------------------------------------------- 59 | % Location of evaluation points: [x1 y1 z1; x2 y2 z2;..] in [mm] 60 | % ------------------------------------------------------------------------- 61 | alva.Xd = [0 0 0; 0 0 10; 0 0 20; 62 | 0 0 30; 0 0 40; 0 0 50; 63 | 0 0 75; 0 0 100; 0 0 150; 64 | 0 0 200; 0 0 250; 0 0 300; 65 | 0 0 350; 0 0 400; 0 0 450; 66 | 0 0 500; 0 0 750; 0 0 1000]; 67 | % ------------------------------------------------------------------------- 68 | % Initialize system and get response 69 | % ------------------------------------------------------------------------- 70 | alva = init_LET(alva); 71 | 72 | % Displacements 73 | ux = alva.ux; 74 | uy = alva.uy; % [mm] 75 | uz = alva.uz; % [mm] 76 | 77 | % Stresses 78 | sigx = alva.sigx; % [MPa] 79 | sigy = alva.sigy; % [MPa] 80 | sigz = alva.sigz; % [MPa] 81 | sigxy = alva.sigxy; % [MPa] 82 | sigyz = alva.sigyz; % [MPa] 83 | sigxz = alva.sigxz; % [MPa] 84 | 85 | % Strains 86 | epsx = alva.epsx.*1e6; % [micro strain] 87 | epsy = alva.epsy.*1e6; % [micro strain] 88 | epsz = alva.epsz.*1e6; % [micro strain] 89 | epsxy = alva.epsxy.*1e6; % [micro strain] 90 | epsyz = alva.epsyz.*1e6; % [micro strain] 91 | epsxz = alva.epsxz.*1e6; % [micro strain] 92 | 93 | % ------------------------------------------------------------------------- 94 | % Validation 95 | % ------------------------------------------------------------------------- 96 | 97 | % Validation using independent software 98 | alva.validation = 'dualdepth'; % select dual wheel load and 99 | % stresses and displacements with 100 | % depth 101 | ellea = validation_let(alva); % Collumns: [length/depth,sigx 102 | % ,sigy,sigx,sigzy,sigzx,sigxy,ux, 103 | % uy,uz] 104 | % ------------------------------------------------------------------------- 105 | % Plotting 106 | % ------------------------------------------------------------------------- 107 | 108 | subplot(2,2,1), title('z-axis displacement (x=y=0)'); 109 | hold on, grid on 110 | plot(uz,alva.Xd(:,3),':ks','LineWidth',1.25,'MarkerSize',5) 111 | hold on 112 | plot(ellea(:,10),ellea(:,1),':b+','LineWidth',1,'MarkerSize',5) 113 | hold on 114 | set(gca,'FontSize',9) 115 | legend({'ALVA','ELLEA1'},'Location','SouthEast') 116 | axis ij 117 | xlabel('Displacement, u_{z} [mm]') 118 | ylabel('z-coordinate [mm]') 119 | hold on 120 | 121 | subplot(2,2,2), title('x-axis stress (x=y=0)'); 122 | hold on, grid on 123 | plot(sigx,alva.Xd(:,3),':ks','LineWidth',1.25,'MarkerSize',5) 124 | hold on 125 | plot(ellea(:,2),ellea(:,1),':b+','LineWidth',1,'MarkerSize',5) 126 | hold on 127 | set(gca,'FontSize',9) 128 | legend({'ALVA','ELLEA1'},'Location','SouthEast') 129 | axis ij 130 | xlabel('Stress, \sigma_{x} [MPa]') 131 | ylabel('Depth, z-axis [mm]') 132 | hold on 133 | 134 | subplot(2,2,3), title('y-axis stress (x=y=0)'); 135 | hold on, grid on 136 | plot(sigy,alva.Xd(:,3),':ks','LineWidth',1.25,'MarkerSize',5) 137 | hold on 138 | plot(ellea(:,3),ellea(:,1),':b+','LineWidth',1,'MarkerSize',5) 139 | hold on 140 | set(gca,'FontSize',9) 141 | legend({'ALVA','ELLEA1'},'Location','SouthEast') 142 | axis ij 143 | xlabel('Stress, \sigma_{y} [MPa]') 144 | ylabel('Depth, z-axis [mm]') 145 | hold on 146 | 147 | subplot(2,2,4), title('z-axis stress (x=y=0)'); 148 | hold on, grid on 149 | plot(sigz,alva.Xd(:,3),':ks','LineWidth',1.25,'MarkerSize',5) 150 | hold on 151 | plot(ellea(:,4),ellea(:,1),':b+','LineWidth',1,'MarkerSize',5) 152 | hold on 153 | set(gca,'FontSize',9) 154 | legend({'ALVA','ELLEA1'},'Location','SouthEast') 155 | axis ij 156 | xlabel('Stress, \sigma_{z} [MPa]') 157 | ylabel('Depth, z-axis [mm]') 158 | hold off 159 | -------------------------------------------------------------------------------- /paper.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 'ALVA: An adaptive MATLAB package for layered viscoelastic analysis' 3 | tags: 4 | - MATLAB 5 | - Layered Elastic Theory 6 | - Linear Viscoelasticity 7 | - Pavement analysis 8 | authors: 9 | - name: Asmus Skar 10 | orcid: 0000-0003-3176-791X 11 | affiliation: 1 12 | - name: Sebastian Andersen 13 | orcid: 0000-0002-6397-7914 14 | affiliation: 1 15 | affiliations: 16 | - name: Department of Civil Engineering, Technical University of Denmark, 2800 Kgs. Lyngby, Denmark 17 | index: 1 18 | date: 29 May 2020 19 | bibliography: paper.bib 20 | --- 21 | 22 | # Introduction 23 | A key component in design and analysis of asphalt pavements is the response model, used to calculate the stresses, strains and displacements in the structure, when subjected to mechanical loading. For many years, response models formulated within the theoretical continuum-mechanics framework of a stratified half-space have been successfully used [@khazanovich:2007a]. In this framework a pavement system is viewed as a collection of layers, each of finite thickness, resting on a semi-infinite medium, also referred to as the Layered Elastic Theory (LET) [@Burmister:1945a]. Several computer programs for the analysis of pavement systems were developed on the basis of LET. However, new design guidelines and in-situ evaluation of mechanical pavement properties entail re-execution of the underlying model many times over, making the response analysis extremely time consuming. This has resulted in development of numerical acceleration techniques for improved computational efficiency [@Erlingsson:2013a;@khazanovich:2007a] implemented in the computer package ELLEA [@Levenberg:2016a]. Moreover, the engineering community is placing increased emphasis on linear viscoelastic characterization of asphalt materials. It is therefore anticipated, that routine pavement-related calculations would soon evolve to include time dependent layer properties and moving loads as supported by the computer packages ViscoRoute [@Chabot:2010a] and ELLVA [@Levenberg:2016b]. Other relevant features for pavement evaluation, incorporated with the computer package GAMES, is the capability of describing both vertical and shear loadings, as well as perfect and deficient bonding along the interfaces of neighboring layers [@Maina:2004a]. 24 | 25 | Although, pavement analysis tools have been developed to address the limitations of conventional LET analysis, there are currently no computer packages that support all aforementioned needs in a unified manner. Moreover, existing software are often limited to standard design problems (e.g., only applicable to a limited number of layers and loads) and the control over the program features is restricted (e.g., source codes not available, implementation not documented, numerical parameters fixed). This paper presents a software, named Adaptive Layered Viscoelastic Analysis (ALVA), with the aim to equip the civil engineering community with an advanced pavement modeling tool and computer package that is highly adaptive, transparent and open-access, capable of supporting current and future pavement evaluation needs. 26 | 27 | # Core algorithm and input parameters 28 | To achieve this, some of the most promising numerical techniques that are currently available for effectively solving elastic and linear viscoelastic layered problems is implemented in a MATLAB computer package. The core algorithm behind this package is based on LET, i.e., the classic formulation for an $N$-layered half-space [@Burmister:1945a], shown in Figure \ref{fig:model}. 29 | 30 | ![$N$-layered half-space model.\label{fig:model}](images/N_layer.png){width=75%} 31 | 32 | In this model all layers are assumed linear elastic, isotropic, homogeneous, and weightless. The model inputs include Young’s modulus $E_{n}$, Poisson’s ratio $\nu_{n}$, and layer thickness $t_{n}$ (where $n$ denotes the layer number). This model is engaged to calculate the response (i.e., stresses and strains) at any point, $A_{j}$, of interest and for a given set of uniformly distributed circular loadings with load radius, $a$, and pressure $q$. In addition ALVA allows users to define horizontally oriented springs operating at the top or bottom layer interfaces to model imperfect interface conditions [@Levenberg:2020a]. Moreover, numerical features for improved code performance are implemented, e.g., acceleration techniques to speed computational time for analysis of surface displacements [@Andersen:2020a] and full response analysis [@khazanovich:2007a; @Levenberg:2016a], as well as an extrapolation technique to improve convergence [@Erlingsson:2013a]. An overview of LET model assumptions and solution procedure is given in [@khazanovich:2007a]. 33 | 34 | The viscoelastic response is approximated based on the LET calculations utilizing the methodology and load scheme suggested by [@Levenberg:2016c] (see Figure \ref{fig:load}). Viscoelastic layers are associated with the short and long time compliances $D_{0}$ and $D_{\infty}$, and shape parameters $\tau_{D}$ and $n_{D}$, controlling the transition between $D_{0}$ and $D_{\infty}$. 35 | 36 | ![Load scheme for simulating a moving load.\label{fig:load}](images/VE_mesh.png){width=95%} 37 | 38 | The load moves in a straight line from $x$=-$x_{0}$ (Start) to $x$=$x_{0}$ (End). The travel path is decomposed into $N$ intervals ($i$=1,…,$N$), each of length $\Delta x$. The point of response evaluation $A_{j}$ is indicated in Figure \ref{fig:load}; this point is located near the middle of the travel path (i.e., $x$-coordinate of zero), at $y$-coordinate $y_{0}$ and depth $z_{0}$ below the surface. 39 | 40 | # Summary and validation 41 | The computer package ALVA offers a solution for the history of response inside the system at any point of interest resulting from a moving load. The code has been validated by comparing ALVA responses at several positions within a pavement system to analytical solutions and other commonly used software packages, i.e.: $(i)$ for a one-layer model with the analytical solution for an elastic half-space, $(ii)$ for elastic multilayered systems with the software package ELLEA [@Levenberg:2016a], and $(iii)$ for viscoelastic multilayered systems with the software package ELLVA [@Levenberg:2016b]. Moreover, the code has been validated against benchmark results, covering a range of commonly used software packages, published by the European Commission [@amadeus:2000a]. The generic computational scheme proposed enables users to control any feature of the program, including geometrical and material properties, layer interface bonding, loading conditions and numerical parameters. Thus, ALVA supports advanced analysis, e.g., detailed analysis of surface tire interaction and unconventional axle loads, and enables users to balance numerical efficiency and accuracy. ALVA can be used as is [@Andersen:2020a;@Skar:2020a] or serve as a computational kernel in new software; supporting future advances in pavement analysis software and development of model-guided data interpretation schemes. 42 | 43 | Future developments of this package may include mathematical formulations to describe more complex phenomena, e.g., $(i)$ fragmented layer conditions (multi-cracked layers); $(ii)$ both isotropic or transversely isotropic properties; $(iii)$ both vertical and horizontal surface loads. 44 | 45 | # Acknowledgements 46 | We thank Eyal Levenberg for many fruitful discussions and Julius Nielsen for his input and improvement of the code performance. 47 | 48 | # References 49 | -------------------------------------------------------------------------------- /basic/numint_coeff_plain.m: -------------------------------------------------------------------------------- 1 | function XipWip = numint_coeff_plain(N,n,Xd,Xl,a,H) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function organizes the integration points and weights for the 5 | % layered elastic half-space equations 6 | 7 | % INPUT PARAMETERS 8 | % N : Number of Bessel roots in integration 9 | % n : Number of integration points in between each Bessel roots 10 | % Xd : Coordinates of evaluation points (x,y,z) 11 | % Xl : Coordinates of load (x,y) 12 | % a : Load radii vector 13 | % H : Depth of layer n-1 out of n layers (i.e. thickness of structure) 14 | %-------------------------------------------------------------------------- 15 | 16 | % Number of loads (xl) and deformation points (xd) 17 | xl = size(Xl,1); % Number of load points 18 | xd = size(Xd,1); % Number of deformation points 19 | 20 | % Alpha - repeated by the number of deformation points all loads influence 21 | alpha = repmat(a/H,[xd,1]); 22 | 23 | % Extend number of evluation points 24 | Xl = repmat(Xl,[xd,1]); % Extends matrix to number of evaluation points 25 | Xd = repmat(Xd,[xl,1]); % Xd is reorganized below to correspond to the 26 | % correct Xl content/sequence 27 | 28 | dx = repmat(1:xd,xl,1); 29 | dx = dx(:)' + repmat(0:xd:xd*(xl-1),1,xd); 30 | Xd = Xd(dx,:); 31 | 32 | % Organize alpha and rho 33 | r = sqrt((Xd(:,1)-Xl(:,1)).^2 + (Xd(:,2)-Xl(:,2)).^2); 34 | 35 | % Introduce the parameter rho (notice: since r is a vector, rho is also 36 | % a vector) 37 | rho = r/H; 38 | 39 | % Identify roots of Bessel functions 40 | B0r = besselroots(0,N,1); % Bessel 0 roots (B0r) 41 | B1r = besselroots(1,N,1); % Bessel 1 roots (B1r) 42 | 43 | % Find nonzero radii/rho (some can be zero if the response at the point of 44 | % loading is considered) 45 | rho_Non0 = find(rho~=0); 46 | 47 | n3 = length(rho); % Number of radii 48 | n4 = length(alpha); % Number of loads: NB: n3 = n4, due to repmat(..) 49 | % commands above 50 | 51 | % Organize matrix with integration points: 52 | % We want to know the m0 and m1-values for the roots, i.e. where 53 | % J0(m0*r) = 0, J1(m1*r) = 0 and J1(m1*a) = 0. These are 54 | % evaluated by taking the above found roots B0r and B1r and as: 55 | % m0 = B0r/r, m1 = B1r/r, m1 = J1/a. The reason why we need the specific m0 56 | % and m1 values is that m-values are included in the the integration as 57 | % separate values. In case r = 0, we have a special case where J0(m0*r) = 58 | % constant and J1(m1*r) = constant. So we do not need parameters for this 59 | % in the integration. We only need integration points for the J1(m1*a). 60 | % So we won't need the m values for the J0(m*r) and J1(m*r) functions. Only 61 | % for J1(m1*a), since it will never be 0. But, below I need the matrix 62 | % size to be consistent. So i put the values to be zero. This does not 63 | % complicate the computations, since (as shown below) we only choose the 64 | % first N nonzero roots in the integration. And we will always have N 65 | % nonzero roots since the radius, a, will always be nonzero. But we still 66 | % need to organize zeros in the roots below, before we can pick N nonzero 67 | % values. 68 | % 69 | % The first xl rows represents the integration points to evaluate the 70 | % deformation of one point due to the xl loads.If a radius is zero, 71 | % division by zero exist 72 | 73 | % Define roots matrices with zeros at B0r spaces and B1r roots at the 74 | % remaining spaces 75 | 76 | roots_z = [zeros(n3,N) repmat(B1r,[n4,1])./repmat(alpha,[1,N])]; 77 | roots_r = [zeros(n3,N) repmat(B1r,[n4,1])./repmat(alpha,[1,N])]; 78 | 79 | % Insert B0r roots in places where rho > 0 (if rho = 0, B0r/rho = NaN). 80 | if isempty(rho_Non0) ~= 1 81 | roots_z(rho_Non0,1:N) = repmat(B0r,[length(rho_Non0),1])./repmat(rho(rho_Non0),[1,N]); 82 | roots_r(rho_Non0,1:N) = repmat(B1r,[length(rho_Non0),1])./repmat(rho(rho_Non0),[1,N]); 83 | end 84 | 85 | % Organize roots in each row in ascending order 86 | roots_z = sort(roots_z')'; 87 | roots_r = sort(roots_r')'; 88 | 89 | % Select the points including up to the first N nonzero zero-value points 90 | % (if we include more than N nonzero zero-value points, we might miss some 91 | % zero points in between <-- because we divide roots by alpha and rho, the 92 | % m-value ranges are different.) 93 | 94 | % Define indx vector to select the nonzero roots 95 | indx = zeros(n3,N); % Organize zero matrix 96 | indx(:) = 1:n3*N; % Fill up matrix with indeces that assume that no 97 | % radius is zero (meaning that roots are present) 98 | 99 | % Replace the indeces where the radius is zero with new indeces where 100 | % integration points are nonzero 101 | indx(find(rho==0),:) = indx(find(rho==0),:) + n3*N; 102 | 103 | % A special case can appear where alpha = rho, i.e., where the deformation 104 | % point is at the edge of the loading. In this case the 105 | % roots_r = [Br/rho Br/alpha], where Br/rho = Br/alpha. So we have the same 106 | % integration points appearing twice. These are arranged side by side after 107 | % we have used the 'sort'-function. So in this case we have to replace the 108 | % index with another index to ensure we do not take out the same values 109 | % twice. This is done below where we add a vector to each of these rows 110 | % given as [0 1 2 3 .... N-2 N-1]*n3, i.e., the collums are shifted (we 111 | % pick out every second column instead of the first N columns). 112 | 113 | indx(find(rho==alpha),:) = indx(find(rho==alpha),:) + (0:N-1)*n3; 114 | 115 | % % if bug in above lone, use this 116 | % if length(find(rho==alpha)>0) 117 | % indx(find(rho==alpha),:) = indx(find(rho==alpha),:) + (0:N-1)*n3; 118 | % end 119 | 120 | % Pick out the nonzero roots 121 | seq_z = [zeros(n3,1) roots_z(indx)]; 122 | seq_r = [zeros(n3,1) roots_r(indx)]; 123 | 124 | % Organize vectors for evaluation of the intermediate integration points 125 | % and the weights 126 | seq_z1 = seq_z(:,1:end-1)'; % <-- Note: transpose, in order for each collumn 127 | % to represent the integration points for ONE 128 | % deformation due to ONE load 129 | seq_z2 = seq_z(:,2:end)'; 130 | seq_r1 = seq_r(:,1:end-1)'; 131 | seq_r2 = seq_r(:,2:end)'; 132 | 133 | % Organize integration points: The way this is organized is that each row 134 | % in xip_z and wip_z contain the points in between two zero points of a 135 | % bessel function. So the first N rows in xip_z contains the integration 136 | % points for one integral The following N rows contain integration points 137 | % for the next integral. We need just one of the integration points for one 138 | % integral to be organized in a single row, and not over multiple rows. A 139 | % reorganization is thus needed afterwards. This is done below. 140 | [xip_z , wip_z]=lookup_gauss(n,seq_z1(:),seq_z2(:)); % z: ip for z-direction 141 | [xip_r , wip_r]=lookup_gauss(n,seq_r1(:),seq_r2(:)); % r: ip for r-direction 142 | 143 | % Reorganize integration points and weights - Every row 144 | % (after reorganization) now refers to a single radius / point-to-load case 145 | xip_z = xip_z'; % First we transform the matrices 146 | xip_r = xip_r'; 147 | xip_z = reshape(xip_z(:),[],n3)'; 148 | xip_r = reshape(xip_r(:),[],n3)'; 149 | 150 | % Reorganize weights 151 | wip_z = wip_z'; 152 | wip_r = wip_r'; 153 | wip_z = reshape(wip_z(:),[],n3)'; 154 | wip_r = reshape(wip_r(:),[],n3)'; 155 | 156 | XipWip = [xip_z; wip_z; xip_r; wip_r]; 157 | -------------------------------------------------------------------------------- /basic/numint_coeff.m: -------------------------------------------------------------------------------- 1 | function XipWip = numint_coeff(N,n,Xd,Xl,a,H) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function organizes the integration points and weights for the 5 | % layered elastic half-space equations 6 | 7 | % The integration is always carried out between the first N zeros of the 8 | % Bessel functions involved. Instead of establishing n integration points, 9 | % only the first interval is integrated using a n-point Gaussian formula. 10 | % The second interval is integrated using a 20-point formula, the third 11 | % interval is integrated using a 10-point formula, and the remaining 12 | % intervals are integrated using a 5-point formula. This formulation is 13 | % chosen to reduce the expense of numerical integration, where most of the 14 | % relevant information is contained between the first two zeros of the 15 | % Bessel functions. It is recommended to use n >= 30. 16 | 17 | % The oranization of integration points and weights are only defined for 18 | % zeros at B0r locations. This is to further expedite the code performance 19 | % at a later stage (i.e., when inferring arbitrary functions), and have 20 | % negligeble influence on the resulting response. 21 | 22 | % INPUT PARAMETERS 23 | % N : Number of Bessel roots in integration 24 | % n : Number of integration points in between each Bessel roots 25 | % Xd : Coordinates of evaluation points (x,y,z) 26 | % Xl : Coordinates of load (x,y) 27 | % a : Load radii vector 28 | % H : Depth of layer n-1 out of n layers (i.e. thickness of structure) 29 | %-------------------------------------------------------------------------- 30 | 31 | % Number of loads (xl) and deformation points (xd) 32 | xl = size(Xl,1); % Number of load points 33 | xd = size(Xd,1); % Number of deformation points 34 | 35 | % Alpha - repeated by the number of deformation points all loads influence 36 | alpha = repmat(a/H,[xd,1]); 37 | 38 | % Extend number of evluation points 39 | Xl = repmat(Xl,[xd,1]); % Extends matrix to number of evaluation points 40 | Xd = repmat(Xd,[xl,1]); % Xd is reorganized below to correspond to the 41 | % correct Xl content/sequence 42 | 43 | dx = repmat(1:xd,xl,1); 44 | dx = dx(:)' + repmat(0:xd:xd*(xl-1),1,xd); 45 | Xd = Xd(dx,:); 46 | 47 | % Organize alpha and rho 48 | r = sqrt((Xd(:,1)-Xl(:,1)).^2 + (Xd(:,2)-Xl(:,2)).^2); 49 | 50 | % Introduce the parameter rho (notice: since r is a vector, rho is also 51 | % a vector) 52 | rho = r/H; 53 | 54 | % Identify roots of Bessel functions 55 | B0r = besselroots(0,N,1); % Bessel 0 roots (B0r) 56 | B1r = besselroots(1,N,1); % Bessel 1 roots (B1r) 57 | 58 | % Find nonzero radii/rho (some can be zero if the response at the point of 59 | % loading is considered) 60 | rho_Non0 = find(rho~=0); 61 | 62 | n3 = length(rho); % Number of radii 63 | n4 = length(alpha); % Number of loads: NB: n3 = n4, due to repmat(..) 64 | % commands above 65 | 66 | % Organize matrix with integration points: 67 | % We want to know the m0 and m1-values for the roots, i.e. where 68 | % J0(m0*r) = 0, J1(m1*r) = 0 and J1(m1*a) = 0. These are 69 | % evaluated by taking the above found roots B0r and B1r and as: 70 | % m0 = B0r/r, m1 = B1r/r, m1 = J1/a. The reason why we need the specific m0 71 | % and m1 values is that m-values are included in the the integration as 72 | % separate values. In case r = 0, we have a special case where J0(m0*r) = 73 | % constant and J1(m1*r) = constant. So we do not need parameters for this 74 | % in the integration. We only need integration points for the J1(m1*a). 75 | % So we won't need the m values for the J0(m*r) and J1(m*r) functions. Only 76 | % for J1(m1*a), since it will never be 0. But, below we need the matrix 77 | % size to be consistent. So we put the values to be zero. This does not 78 | % complicate the computations, since (as shown below) we only choose the 79 | % first N nonzero roots in the integration. And we will always have N 80 | % nonzero roots since the radius, a, will always be nonzero. But we still 81 | % need to organize zeros in the roots below, before we can pick N nonzero 82 | % values. 83 | % 84 | % The first xl rows represents the integration points to evaluate the 85 | % deformation of one point due to the xl loads.If a radius is zero, 86 | % division by zero exist 87 | 88 | % Define roots matrices with zeros at B0r spaces and B1r roots at the 89 | % remaining spaces 90 | roots_z = [zeros(n3,N) repmat(B1r,[n4,1])./repmat(alpha,[1,N])]; 91 | 92 | % Insert B0r roots in places where rho > 0 (if rho = 0, B0r/rho = NaN). 93 | if isempty(rho_Non0) ~= 1 94 | roots_z(rho_Non0,1:N) = repmat(B0r,[length(rho_Non0),1])... 95 | ./repmat(rho(rho_Non0),[1,N]); 96 | end 97 | 98 | % Organize roots in each row in ascending order 99 | roots_z = sort(roots_z')'; 100 | 101 | % Select the points including up to the first N nonzero zero-value points 102 | % (if we include more than N nonzero zero-value points, we might miss some 103 | % zero points in between <-- because we divide roots by alpha and rho, the 104 | % m-value ranges are different.) 105 | 106 | % Define indx vector to select the nonzero roots 107 | indx = zeros(n3,N); % Organize zero matrix 108 | indx(:) = 1:n3*N; % Fill up matrix with indeces that assume that no 109 | % radius is zero (meaning that roots are present) 110 | 111 | % Replace the indeces where the radius is zero with new indeces where 112 | % integration points are nonzero 113 | indx(find(rho==0),:) = indx(find(rho==0),:) + n3*N; 114 | 115 | % A special case can appear where alpha = rho, i.e., where the deformation 116 | % point is at the edge of the loading. In this case the 117 | % roots_r = [Br/rho Br/alpha], where Br/rho = Br/alpha. So we have the same 118 | % integration points appearing twice. These are arranged side by side after 119 | % we have used the 'sort'-function. So in this case we have to replace the 120 | % index with another index to ensure we do not take out the same values 121 | % twice. This is done below where we add a vector to each of these rows 122 | % given as [0 1 2 3 .... N-2 N-1]*n3, i.e., the collums are shifted (we 123 | % pick out every second column instead of the first N columns). 124 | 125 | indx(find(rho==alpha),:) = indx(find(rho==alpha),:) + (0:N-1)*n3; 126 | 127 | % % if bug in above lone, use this 128 | % if length(find(rho==alpha)>0) 129 | % indx(find(rho==alpha),:) = indx(find(rho==alpha),:) + (0:N-1)*n3; 130 | % end 131 | 132 | % Pick out the nonzero roots 133 | seq_z = [zeros(n3,1) roots_z(indx)]; 134 | 135 | % Distribution of n integration points and weights of the first interval 136 | [xip_z1 , wip_z1]=lookup_gauss(n,seq_z(:,1),seq_z(:,2)); 137 | 138 | % Distribution of 20 integration points and weights of the second interval 139 | [xip_z2 , wip_z2]=lookup_gauss(20,seq_z(:,2),seq_z(:,3)); 140 | 141 | % Distribution of 10 integration points and weights of the third interval 142 | [xip_z3 , wip_z3]=lookup_gauss(10,seq_z(:,3),seq_z(:,4)); 143 | 144 | % Define remaining besselzeroes intervals 145 | seq_z1 = seq_z(:,4:end-1)'; % <-- Note: transpose, in order for each collumn 146 | % to represent the integration points for ONE 147 | % deformation due to ONE load 148 | seq_z2 = seq_z(:,5:end)'; 149 | 150 | % Distribution of 5 integration points and weights of the remaining intervals 151 | [xip_z , wip_z]=lookup_gauss(5,seq_z1(:),seq_z2(:)); % z: ip for z-direction 152 | 153 | % Reorganize integration points and weights - Every row 154 | % (after reorganization) now refers to a single radius/point-to-load case 155 | xip_z = xip_z'; % First we transform the matrices 156 | xip_z = reshape(xip_z(:),[],n3)'; 157 | wip_z = wip_z'; 158 | wip_z = reshape(wip_z(:),[],n3)'; 159 | 160 | % Collect all integration points 161 | xip_z = [xip_z1 xip_z2 xip_z3 xip_z]; 162 | xip_r = xip_z; % Uses only the integration point 163 | % defined for zeros at B0r locations 164 | 165 | % Collect all weights 166 | wip_z = [wip_z1 wip_z2 wip_z3 wip_z]; 167 | wip_r = wip_z; 168 | 169 | XipWip = [xip_z; wip_z; xip_r; wip_r]; 170 | -------------------------------------------------------------------------------- /basic/LET_response_polfit.m: -------------------------------------------------------------------------------- 1 | function alva = LET_response_polfit(alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function evaluates the deformations of a layered elastic half space 5 | % model at the surface only, i.e. for z = 0. The approximation method 6 | % proposed by Andersen et al. (2018) is employed. 7 | 8 | % INPUT PARAMETERS: 9 | Xd = alva.Xd; % Output coordinates (x,y,z) 10 | Xl = alva.Xl; % Load posistion coordinates (x,y) 11 | a = alva.a; % Load radii 12 | q = alva.q; % Load pressure 13 | E = alva.E; % Layer Young's moduli 14 | nu = alva.nu; % Layer Poisson's ratios 15 | zi = alva.zi; % Layer interface depths (i.e. depth of layer n-1 out 16 | % of n layers (layer n depth goes to infinity) 17 | XipWip = alva.XipWip; % Integration points and weights used in integration 18 | I = alva.I; % Coefficient proportional integrals 19 | %------------------------------------------------------------------------- 20 | 21 | % If zi has more entries than length(E)-1, these are removed. In principle 22 | % the las entry in zi is infinite. However, the infinite value is not 23 | % included in this code, as we do not operate with infinite number. We 24 | % handle this in an optional way. 25 | if length(zi) <= length(E) 26 | zi(length(E):end) = []; 27 | end 28 | 29 | % The code is organized such that we need a minimum of 2 layers! Check if 30 | % zi has at least one value 31 | if isempty(zi) 32 | display('the code is arranged such that we need minimum two layers!!') 33 | end 34 | 35 | % Define depth of layer n-1 out of n layers (layer n depth goes to infinity) 36 | H = zi(end); 37 | 38 | % Check if the length of E and nu are equal 39 | if length(E) ~= length(nu) 40 | display('length(E) ~= length(nu) !!!') 41 | end 42 | 43 | % Number of loads (xl) and deformation points (xd) 44 | xl = size(Xl,1); % Number of load points 45 | xd = size(Xd,1); % Number of deformation points 46 | 47 | % Make sure that the length of q and a are correct. These should be equal 48 | % to the number of loads. 49 | if length(q) < xl || length(a) < xl 50 | display('Number of q and/or a values is lower than the number of load coordinates (= number of loads), so all loads are given the same q- and a-values') 51 | q = q(1)*ones(xl,1); 52 | a = a(1)*ones(xl,1); 53 | end 54 | 55 | % Make sure that q and a are vectors "standing up" 56 | if size(q,1) < size(q,2) 57 | q = q'; 58 | end 59 | 60 | if size(a,1) < size(a,2) 61 | a = a'; 62 | end 63 | 64 | % Make sure that zi is a 'horizontal' vector 65 | if size(zi,1) > size(zi,2) 66 | zi = zi'; 67 | end 68 | 69 | % Increase Xl, q, alpha, Xd and z in order to estimate the radius from each 70 | % of the loads to all of the points. The number of radii are: xl*xd 71 | Xl = repmat(Xl,[xd,1]); % Extends with the number of evaluation 72 | % points 73 | q = repmat(q,[xd,1]); % -||- 74 | alpha = repmat(a/H,[xd,1]); % -||- 75 | Xd = repmat(Xd,[xl,1]); % -||- <-- is reorganized below to 76 | % correspond to the right Xl content/sequence 77 | 78 | % Reorganize Xd so the first xl rows correspond to the same deformation 79 | % point, and following xl rows correspond to the next deformation point 80 | % etc... see description of the vector r nine lines below to understand 81 | % the organization 82 | dx = repmat(1:xd,xl,1); 83 | dx = dx(:)' + repmat(0:xd:xd*(xl-1),1,xd); 84 | Xd = Xd(dx,:); 85 | 86 | % Evaluate the radii between deformation points and loads 87 | % r = [ deformation point 1 and load 1 88 | % deformation point 1 and load 2 89 | % deformation point 1 and load 3 90 | % . 91 | % deformation point 1 and load N 92 | % deformation point 2 and load 1 93 | % deformation point 2 and load 2 94 | % . 95 | % . 96 | % last deformation point and load N]; 97 | 98 | r = sqrt((Xd(:,1)-Xl(:,1)).^2 + (Xd(:,2)-Xl(:,2)).^2); 99 | 100 | % Introduce the parameter rho (notice: since r is a vector, rho is too) 101 | rho = r/H; 102 | 103 | % Integration points and weights 104 | lrho = length(rho); % Number of load-to-displacement-points 105 | xip_z = XipWip(0*lrho+1:1*lrho,:); 106 | wip_z = XipWip(1*lrho+1:2*lrho,:); 107 | xip_r = XipWip(2*lrho+1:3*lrho,:); 108 | wip_r = XipWip(3*lrho+1:4*lrho,:); 109 | 110 | % Number of columns in reorganized integration points and weights (=number 111 | % of integration points per integral) 112 | nz = size(xip_z,2); % = size(xip_r,2); 113 | 114 | % Interpolate A, B, C and D values used for integration 115 | [Az,Bz,Cz,Dz,Ar,Br,Cr,Dr]=arb_func_polfit(E,nu,zi,xip_z,xip_r,lrho,alva); 116 | 117 | % Poisson's ratio and Youngs Modulus for the top layer 118 | Nu = nu(1); 119 | Ee = E(1); 120 | Lam1 = zi(1)/H; 121 | 122 | % Evaluate abc values 123 | abc_zr = polfit_abc(E,nu,zi,Lam1,alva); % ,ABCD added 124 | 125 | abc_z = abc_zr(1,:); 126 | abc_r = abc_zr(2,:); 127 | 128 | % Organize polynomials for the approximation of the A, B, C and D coefficients 129 | polz = (abc_z(1).*xip_z.^2+abc_z(2).*xip_z+abc_z(3)).*exp(-2*Lam1*xip_z)-(2-2*Nu); 130 | polr = (abc_r(1).*xip_r.^2+abc_r(2).*xip_r+abc_r(3)).*exp(-2*Lam1*xip_r)-(1-2*Nu); 131 | 132 | % Speeded up solution for the radial displacements, ur: 133 | ur = besselj(1,xip_r.*repmat(rho,1,nz)).*... 134 | (... 135 | (Ar+Cr).*exp(-xip_r*Lam1)+... 136 | (Br-Dr)-polr... 137 | ); 138 | 139 | ur = q.*alpha.*H*(1+Nu)/Ee.*sum(ur.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r,2); 140 | 141 | % Evaluate polynimial integral contribution 142 | urp = q/Ee.*(abc_r(1)*I(:,5)+abc_r(2)*I(:,6)+abc_r(3)*I(:,7)+I(:,8)); 143 | 144 | % Add polynomial integrals to ur 145 | ur = ur + urp; 146 | 147 | % Polynomial fit solution 148 | uz = besselj(0,xip_z.*repmat(rho,1,nz)).*... 149 | (... 150 | (Az-Cz.*(2-4*Nu)).*exp(-xip_z.*Lam1)-... 151 | (Bz+Dz.*(2-4*Nu))-polz... 152 | ); 153 | 154 | uz = q.*alpha.*(-1)*H.*(1+Nu)./Ee.*... 155 | sum(uz.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z,2); 156 | 157 | % Evaluate polynomial integral contributions 158 | uzp = q/Ee.*(abc_z(1)*I(:,1)+abc_z(2)*I(:,2)+abc_z(3)*I(:,3)+I(:,4)); 159 | 160 | % Add polynomial solution to uz 161 | uz = uz + uzp; 162 | 163 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 164 | 165 | %%%%% Transformation between (r,theta) and (x,y) co-ordinates %%%%%%%%%%%%% 166 | % Below a transformation of each of the deformations evaluated above from 167 | % the (r,theta) coordinates to the (x,y) coordinates are made. After the 168 | % transformation, the deformations are added together. 169 | 170 | % p (load point) 171 | % (z is downwards) 172 | % z-> x ^ (deformation vector ur; pointing towards the load) 173 | % | / 174 | % y v / 175 | % o (deformation point) 176 | % 177 | % NB: the r-axis (goes in the direction 178 | 179 | 180 | % Transformation matrix (each point-to-load radius results in 3 deformations) 181 | T = sparse(3*length(r),3*length(r),(3*3-4)*length(r)); 182 | 183 | % Organize content of the T matrix 184 | COS = (Xd(:,1)-Xl(:,1))./r; 185 | SIN = (Xd(:,2)-Xl(:,2))./r; % Minus on y-coordinate because z-axis points 186 | % downward 187 | 188 | % Replace content in COS and SIN with, respectively, 1 and 0 if r = 0 189 | COS(find(r==0)) = 1; 190 | SIN(find(r==0)) = 0; 191 | 192 | % Transformation matrix is denoted S (and we use its transpose = inverse 193 | % in the transformation). This is given as: 194 | % S = T =[ cos(theta) sin(theta) 0 = [ Xd(:,1)-Xl(:,1) , Xd(:,2)-Xl(:,2) , 0 195 | % -sin(theta) cos(theta) 0 -(Xd(:,2)-Xl(:,2)) , Xd(:,1)-Xl(:,1) , 0 196 | % 0 0 1]; 0 , 0 , r]*1/r; 197 | 198 | % Address the content into the matrix 199 | T(1:3*3*length(r)+3:end) = COS; 200 | T(2:3*3*length(r)+3:end) = -SIN; 201 | T(3*length(r)+1:3*3*length(r)+3:end) = SIN; 202 | T(3*length(r)+2:3*3*length(r)+3:end) = COS; 203 | T(2*3*length(r)+3:3*3*length(r)+3:end) = 1; 204 | 205 | % Organize displacement vector 206 | u1 = zeros(length(r)*3,1); 207 | u1(1:3:end) = ur; 208 | %u1(2:3:end) = 0; % Displacements transverse to the radius (u_theta = 0) 209 | u1(3:3:end) = uz; 210 | 211 | % Transform deformations in to (x,y,z)-coordinates 212 | u1=T'*u1; 213 | u=u1; 214 | 215 | % Organize matrix Txyz for adding displacements together 216 | unos = zeros(3*xd*xl,1); % Number of ones in Txyz 217 | unos(1:xl)=1:9*xd:9*xl*xd; 218 | unos(xl+1:2*xl)=unos(1:xl)+3*xd+1; 219 | unos(2*xl+1:3*xl)=unos(1:xl)+2*3*xd+2; 220 | 221 | for i=1:xd-1 222 | unos(3*xl+1+3*xl*(i-1):3*xl+3*xl*i)=unos(1:3*xl)+i*(3*xd*3*xl+3); 223 | end 224 | 225 | % Matrix adding contributions together from different loads 226 | Txyz = spalloc(3*xd,3*length(r),length(unos)); 227 | Txyz(unos) = 1; 228 | 229 | % Final displacement vector 230 | u = Txyz*u; 231 | 232 | alva.ux = u(1:3:end-2); 233 | alva.uy = u(2:3:end-1); 234 | alva.uz = u(3:3:end); -------------------------------------------------------------------------------- /validation/validation_let.m: -------------------------------------------------------------------------------- 1 | function response = validation_let(alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function looks up calculated response for different validation 5 | % cases using the computer program ELLEA1 [1] 6 | % ------------------------------------------------------------------------- 7 | % References 8 | % ------------------------------------------------------------------------- 9 | % [1] Levenberg, E. (2016). ELLEA1: Isotropic Layered Elasticity in Excel: 10 | % Pavement analysis tool for students and engineers" 11 | 12 | %------------------------------------------------------------------------- 13 | % Output response 14 | % Collumns: 1:depth/length 2:sig_x 3:sig_y 4:sig_z 5:sig_yz 6:sig_xz 15 | % 7:sig_xy 8:ux 9:uy 10:uz 16 | %------------------------------------------------------------------------- 17 | 18 | if strcmp(alva.validation,'singledepth') > 0 19 | response = [0 2.3501 2.3501 1.0998 0.0000 0.0000 0.0000 0.0000 0.0000 1.0508 20 | 10 2.0253 2.0253 1.0923 0.0000 0.0000 0.0000 0.0000 0.0000 1.0515 21 | 20 1.7171 1.7171 1.0703 0.0000 0.0000 0.0000 0.0000 0.0000 1.0516 22 | 30 1.4244 1.4244 1.0346 0.0000 0.0000 0.0000 0.0000 0.0000 1.0513 23 | 40 1.1460 1.1460 0.9864 0.0000 0.0000 0.0000 0.0000 0.0000 1.0505 24 | 50 0.8803 0.8803 0.9271 0.0000 0.0000 0.0000 0.0000 0.0000 1.0493 25 | 75 0.2577 0.2577 0.7431 0.0000 0.0000 0.0000 0.0000 0.0000 1.0451 26 | 100 -0.3396 -0.3396 0.5405 0.0000 0.0000 0.0000 0.0000 0.0000 1.0396 27 | 150 -1.6757 -1.6757 0.2752 0.0000 0.0000 0.0000 0.0000 0.0000 1.0235 28 | 200 0.0067 0.0067 0.2172 0.0000 0.0000 0.0000 0.0000 0.0000 0.9644 29 | 250 -0.0010 -0.0010 0.1728 0.0000 0.0000 0.0000 0.0000 0.0000 0.9163 30 | 300 -0.0064 -0.0064 0.1388 0.0000 0.0000 0.0000 0.0000 0.0000 0.8769 31 | 350 -0.0109 -0.0109 0.1123 0.0000 0.0000 0.0000 0.0000 0.0000 0.8441 32 | 400 -0.0149 -0.0149 0.0911 0.0000 0.0000 0.0000 0.0000 0.0000 0.8165 33 | 450 -0.0189 -0.0189 0.0739 0.0000 0.0000 0.0000 0.0000 0.0000 0.7930 34 | 500 -0.0233 -0.0233 0.0598 0.0000 0.0000 0.0000 0.0000 0.0000 0.7726 35 | 750 -0.0600 -0.0600 0.0220 0.0000 0.0000 0.0000 0.0000 0.0000 0.6931 36 | 1000 -0.0005 -0.0005 0.0146 0.0000 0.0000 0.0000 0.0000 0.0000 0.5777 37 | ]; 38 | elseif strcmp(alva.validation,'dualdepth') > 0 39 | response = [ 40 | 0 3.3371 2.4360 1.0957 0.0000 0.0000 0.0000 0.0000 0.0000 1.9174 41 | 10 2.7463 2.1929 1.0708 0.0000 0.0000 0.0000 0.0000 0.0000 1.9191 42 | 20 2.2753 1.9296 1.0326 0.0000 0.0000 0.0000 0.0000 0.0000 1.9202 43 | 30 1.8581 1.6627 0.9863 0.0000 0.0000 0.0000 0.0000 0.0000 1.9207 44 | 40 1.4763 1.3955 0.9335 0.0000 0.0000 0.0000 0.0000 0.0000 1.9207 45 | 50 1.1197 1.1293 0.8758 0.0000 0.0000 0.0000 0.0000 0.0000 1.9202 46 | 75 0.2936 0.4705 0.7202 0.0000 0.0000 0.0000 0.0000 0.0000 1.9173 47 | 100 -0.5021 -0.1813 0.5674 0.0000 0.0000 0.0000 0.0000 0.0000 1.9121 48 | 150 -2.2806 -1.4829 0.3726 0.0000 0.0000 0.0000 0.0000 0.0000 1.8936 49 | 200 0.0101 0.0456 0.3148 0.0000 0.0000 0.0000 0.0000 0.0000 1.8148 50 | 250 -0.0028 0.0221 0.2649 0.0000 0.0000 0.0000 0.0000 0.0000 1.7457 51 | 300 -0.0127 0.0050 0.2221 0.0000 0.0000 0.0000 0.0000 0.0000 1.6855 52 | 350 -0.0211 -0.0082 0.1856 0.0000 0.0000 0.0000 0.0000 0.0000 1.6330 53 | 400 -0.0288 -0.0193 0.1546 0.0000 0.0000 0.0000 0.0000 0.0000 1.5871 54 | 450 -0.0366 -0.0294 0.1281 0.0000 0.0000 0.0000 0.0000 0.0000 1.5469 55 | 500 -0.0450 -0.0394 0.1055 0.0000 0.0000 0.0000 0.0000 0.0000 1.5112 56 | 750 -0.1144 -0.1102 0.0419 0.0000 0.0000 0.0000 0.0000 0.0000 1.3645 57 | 1000 -0.0009 -0.0006 0.0284 0.0000 0.0000 0.0000 0.0000 0.0000 1.1442 58 | ]; 59 | elseif strcmp(alva.validation,'duallength') > 0 60 | response =[0 3.3371 2.4360 1.0957 0.0000 0.0000 0.0000 0.0000 0.0000 1.9174 61 | 50 2.4467 1.4111 -0.0005 0.0000 0.0000 0.0000 -0.0365 0.0000 1.8929 62 | 100 1.9429 1.4801 0.0023 0.0000 0.0000 0.0000 -0.0660 0.0000 1.8416 63 | 150 1.4102 1.4102 0.0006 0.0000 0.0000 0.0000 -0.0866 0.0000 1.7772 64 | 200 0.9406 1.2520 -0.0011 0.0000 0.0000 0.0000 -0.0994 0.0000 1.7063 65 | 250 0.5680 1.0729 -0.0013 0.0000 0.0000 0.0000 -0.1060 0.0000 1.6333 66 | 300 0.2970 0.9062 -0.0019 0.0000 0.0000 0.0000 -0.1082 0.0000 1.5614 67 | 350 0.1146 0.7640 -0.0016 0.0000 0.0000 0.0000 -0.1073 0.0000 1.4923 68 | 400 -0.0001 0.6474 -0.0005 0.0000 0.0000 0.0000 -0.1047 0.0000 1.4272 69 | 450 -0.0694 0.5520 -0.0007 0.0000 0.0000 0.0000 -0.1011 0.0000 1.3665 70 | 500 -0.1064 0.4754 -0.0003 0.0000 0.0000 0.0000 -0.0970 0.0000 1.3101 71 | 750 -0.1082 0.2605 -0.0001 0.0000 0.0000 0.0000 -0.0782 0.0000 1.0843 72 | 1000 -0.0688 0.1696 -0.0001 0.0000 0.0000 0.0000 -0.0658 0.0000 0.9232 73 | 1500 -0.0484 0.0849 0.0001 0.0000 0.0000 0.0000 -0.0506 0.0000 0.6995 74 | 2000 -0.0425 0.0463 0.0000 0.0000 0.0000 0.0000 -0.0398 0.0000 0.5484 75 | 3000 -0.0277 0.0167 -0.0009 0.0000 0.0000 0.0000 -0.0254 0.0000 0.3657]; 76 | elseif strcmp(alva.validation,'halfspace') > 0 77 | response = [0 0.9349 0.9349 1.0999 0.0000 0.0000 0.0000 0.0000 0.0000 1.4478 78 | 10 0.8364 0.8364 1.0997 0.0000 0.0000 0.0000 0.0000 0.0000 1.4238 79 | 20 0.7400 0.7400 1.0975 0.0000 0.0000 0.0000 0.0000 0.0000 1.3964 80 | 30 0.6479 0.6479 1.0917 0.0000 0.0000 0.0000 0.0000 0.0000 1.3660 81 | 40 0.5617 0.5617 1.0812 0.0000 0.0000 0.0000 0.0000 0.0000 1.3328 82 | 50 0.4828 0.4828 1.0652 0.0000 0.0000 0.0000 0.0000 0.0000 1.2974 83 | 75 0.3200 0.3200 1.0016 0.0000 0.0000 0.0000 0.0000 0.0000 1.2026 84 | 100 0.2051 0.2051 0.9122 0.0000 0.0000 0.0000 0.0000 0.0000 1.1055 85 | 150 0.0794 0.0794 0.7110 0.0000 0.0000 0.0000 0.0000 0.0000 0.9259 86 | 200 0.0286 0.0286 0.5367 0.0000 0.0000 0.0000 0.0000 0.0000 0.7796 87 | 250 0.0084 0.0084 0.4064 0.0000 0.0000 0.0000 0.0000 0.0000 0.6655 88 | 300 0.0003 0.0003 0.3129 0.0000 0.0000 0.0000 0.0000 0.0000 0.5769 89 | 350 -0.0028 -0.0028 0.2458 0.0000 0.0000 0.0000 0.0000 0.0000 0.5073 90 | 400 -0.0039 -0.0039 0.1970 0.0000 0.0000 0.0000 0.0000 0.0000 0.4516 91 | 450 -0.0042 -0.0042 0.1608 0.0000 0.0000 0.0000 0.0000 0.0000 0.4064 92 | 500 -0.0041 -0.0041 0.1334 0.0000 0.0000 0.0000 0.0000 0.0000 0.3691 93 | 750 -0.0026 -0.0026 0.0628 0.0000 0.0000 0.0000 0.0000 0.0000 0.2515 94 | 1000 -0.0016 -0.0016 0.0361 0.0000 0.0000 0.0000 0.0000 0.0000 0.1901 95 | ]; 96 | elseif strcmp(alva.validation,'halfspace_shear') > 0 97 | response = [0 0.9350 0.9349 1.0999 0.0000 0.0000 0.0000 -0.0111 -0.0223 1.4397 98 | 10 0.8350 0.8345 1.0996 0.0010 0.0005 -0.0003 -0.0079 -0.0158 1.4157 99 | 20 0.7373 0.7364 1.0972 0.0039 0.0019 -0.0006 -0.0048 -0.0096 1.3883 100 | 30 0.6442 0.6431 1.0910 0.0083 0.0041 -0.0008 -0.0019 -0.0038 1.3577 101 | 40 0.5574 0.5562 1.0797 0.0136 0.0068 -0.0008 0.0007 0.0015 1.3244 102 | 50 0.4781 0.4770 1.0628 0.0193 0.0097 -0.0008 0.0030 0.0060 1.2889 103 | 75 0.3158 0.3154 0.9962 0.0321 0.0160 -0.0003 0.0072 0.0143 1.1942 104 | 100 0.2021 0.2025 0.9046 0.0393 0.0197 0.0003 0.0093 0.0186 1.0975 105 | 150 0.0785 0.0797 0.7029 0.0387 0.0194 0.0008 0.0098 0.0196 0.9198 106 | 200 0.0285 0.0296 0.5307 0.0302 0.0151 0.0007 0.0084 0.0168 0.7753 107 | 250 0.0086 0.0093 0.4024 0.0219 0.0109 0.0005 0.0068 0.0136 0.6626 108 | 300 0.0005 0.0010 0.3103 0.0156 0.0078 0.0004 0.0054 0.0109 0.5749 109 | 350 -0.0027 -0.0024 0.2441 0.0113 0.0056 0.0002 0.0044 0.0087 0.5059 110 | 400 -0.0039 -0.0036 0.1958 0.0083 0.0042 0.0002 0.0036 0.0071 0.4506 111 | 450 -0.0041 -0.0040 0.1600 0.0062 0.0031 0.0001 0.0029 0.0059 0.4056 112 | 500 -0.0040 -0.0039 0.1328 0.0048 0.0024 0.0001 0.0025 0.0049 0.3685 113 | 750 -0.0026 -0.0025 0.0627 0.0016 0.0008 0.0000 0.0012 0.0024 0.2513 114 | 1000 -0.0016 -0.0016 0.0361 0.0007 0.0004 0.0000 0.0007 0.0014 0.1900 115 | ]; 116 | elseif strcmp(alva.validation,'halfspace_shear_strain') > 0 117 | % format: [eps_x eps_y eps_z eps_xy eps_yz eps_xz 118 | response = [ 119 | 0 736.6859 389.9417 -210.2096 -9.4578 -0.0006 0.0007 120 | 10 593.8950 343.2896 -132.3018 1.0855 -4.4535 8.1273 121 | 20 468.4325 302.7134 -70.5882 4.5071 -9.6577 17.3330 122 | 30 359.5222 261.2682 -18.5650 4.4650 -11.1794 23.4490 123 | 40 263.1367 217.2765 27.7279 3.6572 -10.8141 27.1034 124 | 50 175.8194 171.3471 69.9623 2.8524 -9.7224 29.1766 125 | 75 -19.1248 52.1867 165.1114 1.5396 -6.4335 30.0798 126 | 100 -204.0480 -68.9493 257.8612 1.0040 -3.7112 26.4775 127 | 150 -645.5158 -306.0617 499.9204 1.3688 2.2696 4.2175 128 | 200 -577.7007 -340.9639 1473.3037 0.9234 42.4749 51.3710 129 | 250 -514.2167 -347.6736 1287.1622 0.7365 43.0236 40.8279 130 | 300 -459.5256 -340.5053 1120.9192 0.6007 40.4834 32.9230 131 | 350 -414.8097 -328.1782 976.9886 0.4867 36.7254 26.9204 132 | 400 -380.0564 -315.8148 855.1341 0.3921 32.6738 22.2754 133 | 450 -355.1578 -306.4883 754.4073 0.3168 28.7169 18.6013 134 | 500 -340.0644 -302.2585 673.8017 0.2592 24.9610 15.5897 135 | 750 -452.0891 -423.3760 601.8378 0.2236 4.6629 2.6201 136 | 1000 -300.8785 -289.0444 724.5183 0.0965 13.3008 7.1316 137 | ]; 138 | else 139 | error('Validation case not in library') 140 | end 141 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [2020] [Technical University of Denmark] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /examples/ALVA_bonding_validation1.m: -------------------------------------------------------------------------------- 1 | % DESCRIPTION: 2 | % This script tests the implementation of the ALVA LET model, calculating 3 | % responses at key locations for a multilayered pavement subjected to a 4 | % single load and a dual load respectively utilizing the method proposed. 5 | % The results are compared to benchmark results reported by the European 6 | % Commission (Belgian Road Research Centre, 2000). 7 | % ------------------------------------------------------------------------- 8 | % References 9 | % ------------------------------------------------------------------------- 10 | % Belgian Road Research Centre. (2000). Advanced models for analytical 11 | % design of european pavement structures. Brussels, Belgium: European 12 | % Commission. Retrieved from https://trimis.ec.europa.eu/project/... 13 | % advanced-models-analytical-design-european-pavement-structures 14 | 15 | clear all, close all, clc 16 | 17 | % ------------------------------------------------------------------------- 18 | % Select response analysis type 19 | % ------------------------------------------------------------------------- 20 | alva.analysis = 'Full'; 21 | % 1) 'Full' : Conventional full integration with one-step Richardson 22 | % extrapolation (for improved convergence near surface) 23 | % applied for evaluation of displacements and stresses 24 | % 2) 'PolFit' : Use polynomial fit technique to reduce integral length 25 | % according to Andersen et al. (2018) for evaluation of 26 | % surface displacements 27 | 28 | % ------------------------------------------------------------------------- 29 | % Numerical parameters 30 | % ------------------------------------------------------------------------- 31 | alva.N = 300; % Number of Bessel zero points in numerical integration 32 | alva.n = 30; % Number of Gauss points points between zero points. 33 | 34 | % ------------------------------------------------------------------------- 35 | % Pavement material properties (minimum two layers required) 36 | % ------------------------------------------------------------------------- 37 | alva.zi = [260 760]; % Depth of first n-1 layers from the 38 | % surface [mm]: last z = inf, and should not 39 | % be added NB: zi(i) > zi(i-1) > z(i-2)... 40 | alva.E = [5000 200 50]; % Layer Young's moduli [MPa] 41 | alva.nu = [0.35 0.40 0.45]; % Layer Poisson's ratio [-] 42 | 43 | % ------------------------------------------------------------------------- 44 | % Load configuration - Single case 45 | % ------------------------------------------------------------------------- 46 | 47 | alva.q = [0.7]; % Load pressure [MPa] (uniform vertical pressure) 48 | alva.a = [150.8]; % Load radii [mm] (circular load) 49 | alva.Xl = [0.0 0.0]; % Load positions [mm]: [x1 y1; x2 y2;..xi yi]; 50 | 51 | % ------------------------------------------------------------------------- 52 | % Location of evaluation points: [x1 y1 z1; x2 y2 z2;..] - Single case 53 | % ------------------------------------------------------------------------- 54 | alva.Xd = [ 0 0 0; 0 0 259.9; 0 0 260.01; 0 0 760.1; 55 | 150.8 0 0; 151 0 259.9; 150.8 0 260.01; 150.8 0 760.1 56 | ]; 57 | 58 | % ------------------------------------------------------------------------- 59 | % Initialize system and get response - Single case 60 | % ------------------------------------------------------------------------- 61 | 62 | % Case 1: Full bond both interfaces 63 | alva.bond = 'Bonded'; 64 | alva = init_LET(alva); 65 | 66 | % Stresses 67 | sigz1s = alva.sigz; % [MPa] 68 | 69 | % Strains 70 | epsx1s = alva.epsx.*1e6; % [micro strain] 71 | epsy1s = alva.epsy.*1e6; % [micro strain] 72 | epsz1s = alva.epsz.*1e6; % [micro strain] 73 | 74 | % Case 2: Full bond both interfaces - kh is high 75 | alva.bond = 'Slip'; 76 | alva.kh = [1e6 1e6]; % Interface bonding/horizontal spring [MPa/mm] 77 | 78 | alva = init_LET(alva); 79 | 80 | % Stresses 81 | sigz2s = alva.sigz; % [MPa] 82 | 83 | % Strains 84 | epsx2s = alva.epsx.*1e6; % [micro strain] 85 | epsy2s = alva.epsy.*1e6; % [micro strain] 86 | epsz2s = alva.epsz.*1e6; % [micro strain] 87 | 88 | 89 | % Case 3: Reduceed bond interface 1 - kh is low 90 | alva.bond = 'Slip'; 91 | alva.kh = [1e-6 1e6]; % Interface bonding/horizontal spring [MPa/mm] 92 | 93 | alva = init_LET(alva); 94 | 95 | % Stresses 96 | sigz3s = alva.sigz; % [MPa] 97 | 98 | % Strains 99 | epsx3s = alva.epsx.*1e6; % [micro strain] 100 | epsy3s = alva.epsy.*1e6; % [micro strain] 101 | epsz3s = alva.epsz.*1e6; % [micro strain] 102 | 103 | % ------------------------------------------------------------------------- 104 | % Load configuration - Dual case 105 | % ------------------------------------------------------------------------- 106 | 107 | alva.q = [0.7 108 | 0.7]; % Load pressure [MPa] (uniform vertical pressure) 109 | alva.a = [106.6 110 | 106.6]; % Load radii [mm] (circular load) 111 | alva.Xl = [-170 0.0 112 | 170 0.0]; % Load positions [mm]: [x1 y1; x2 y2;..xi yi]; 113 | 114 | % ------------------------------------------------------------------------- 115 | % Location of evaluation points: [x1 y1 z1; x2 y2 z2;..] - Dual case 116 | % ------------------------------------------------------------------------- 117 | 118 | alva.Xd = [ 119 | 170 0 0; 170 0 259.99; 170 0 260.1; 170 0 760.1; 120 | 0 0 0; 0 0 259.99; 0 0 260.1; 0 0 760.1 121 | ]; 122 | 123 | % ------------------------------------------------------------------------- 124 | % Initialize system and get response 125 | % ------------------------------------------------------------------------- 126 | 127 | % Case 1: Full bond both interfaces 128 | alva.bond = 'Bonded'; 129 | alva = init_LET(alva); 130 | 131 | % Stresses 132 | sigz1d = alva.sigz; % [MPa] 133 | 134 | % Strains 135 | epsx1d = alva.epsx.*1e6; % [micro strain] 136 | epsy1d = alva.epsy.*1e6; % [micro strain] 137 | epsz1d = alva.epsz.*1e6; % [micro strain] 138 | 139 | % Case 2: Full bond both interfaces - kh is high 140 | alva.bond = 'Slip'; 141 | alva.kh = [1e6 1e6]; % Interface bonding/horizontal spring [MPa/mm] 142 | 143 | alva = init_LET(alva); 144 | 145 | % Stresses 146 | sigz2d = alva.sigz; % [MPa] 147 | 148 | % Strains 149 | epsx2d = alva.epsx.*1e6; % [micro strain] 150 | epsy2d = alva.epsy.*1e6; % [micro strain] 151 | epsz2d = alva.epsz.*1e6; % [micro strain] 152 | 153 | % Case 3: Reduceed bond interface 1 - kh is low 154 | alva.bond = 'Slip'; 155 | alva.kh = [1e-6 1e6]; % Interface bonding/horizontal spring [MPa/mm] 156 | 157 | alva = init_LET(alva); 158 | 159 | % Stresses 160 | sigz3d = alva.sigz; % [MPa] 161 | 162 | % Strains 163 | epsx3d = alva.epsx.*1e6; % [micro strain] 164 | epsy3d = alva.epsy.*1e6; % [micro strain] 165 | epsz3d = alva.epsz.*1e6; % [micro strain] 166 | 167 | % ------------------------------------------------------------------------- 168 | % Validation: [sigmaz(c) epsh(c) epsz(c) epsz(c) sigmaz(e) epsh(e) 169 | % epsz(e) epsz(e)]; where (c) and (e) indicate center and edge of load, 170 | % respectively 171 | % ------------------------------------------------------------------------- 172 | 173 | bond_single = [0.700 -100.5 251.7 185.0 0.350 -61.9 192.2 177.5; 174 | 0.817 -100.5 251.6 185.3 0.319 -62.0 192.2 177.0; 175 | 0.700 -100.5 251.6 185.1 0.345 -61.9 192.2 177.5]; 176 | 177 | slip_single = [0.700 -120 1 217 0.350 -78 -10 205; 178 | 0.700 -120 1 216 0.000 -78 -10 205; 179 | 0.700 -119 11 217 0.000 -77 -1 205]; 180 | 181 | bond_dual = [0.700 0 186 170 0.0000 0 182 177; 182 | 1.466 -85 186 170 -0.0045 -89 183 177; 183 | 0.700 -85 186 170 0.0000 -89 183 177]; 184 | 185 | slip_dual = [0.700 0 9 193 0.0000 0 -12 204; 186 | 0.700 -120 -1 216 0.0000 -78 -10 205; 187 | 0.700 -101 -3 194 0.0000 -106 1 205]; 188 | 189 | 190 | % ------------------------------------------------------------------------- 191 | % Plot results (table function not compatible with Octave) 192 | % ------------------------------------------------------------------------- 193 | 194 | Location = {'R1';'R2';'R3';'R4';'R5';'R6';'R7';'R8'}; 195 | Description = [{'Vertical stress surface at center of load'};... 196 | {'Horizontal strain bottom layer 1 at center of load'};... 197 | {'Vertical strain top layer 2 at center of load'};... 198 | {'Vertical strain top layer 3 at center of load'};... 199 | {'Vertical stress surface at edge of load'};... 200 | {'Horizontal strain bottom layer 1 at edge of load'};... 201 | {'Vertical strain top layer 2 at edge of load'};... 202 | {'Vertical strain top layer 3 at edge of load'}]; 203 | %TableGuide = table(Description,'RowNames',Location) 204 | 205 | TableGuide = [{'R1: Vertical stress surface at center of load'};... 206 | {'R2: Horizontal strain bottom layer 1 at center of load'};... 207 | {'R3: Vertical strain top layer 2 at center of load'};... 208 | {'R4: Vertical strain top layer 3 at center of load'};... 209 | {'R5: Vertical stress surface at edge of load'};... 210 | {'R6: Horizontal strain bottom layer 1 at edge of load'};... 211 | {'R7: Vertical strain top layer 2 at edge of load'};... 212 | {'R8: Vertical strain top layer 3 at edge of load'}] 213 | 214 | CodeName1 = {'BISAR';'KENLAYER';'GAMES';'ALVA (slip)';'ALVA (bond)'} 215 | CodeName2 = {'BISAR';'KENLAYER';'GAMES';'ALVA (slip)'}; 216 | 217 | % Single wheel bonded interfaces 218 | A1sb = [bond_single(:,1);sigz2s(1);sigz1s(1)]; 219 | A2sb = [bond_single(:,2);epsx2s(2);epsx1s(2)]; 220 | A3sb = [bond_single(:,3);epsz2s(3);epsz1s(3)]; 221 | A4sb = [bond_single(:,4);epsz2s(4);epsz1s(4)]; 222 | A5sb = [bond_single(:,5);sigz2s(5);sigz1s(5)]; 223 | A6sb = [bond_single(:,6);epsx2s(6);epsx1s(6)]; 224 | A7sb = [bond_single(:,7);epsz2s(7);epsz1s(7)]; 225 | A8sb = [bond_single(:,8);epsz2s(8);epsz1s(8)]; 226 | %SingleWheelBond = table(A1sb,A2sb,A3sb,A4sb,A5sb,A6sb,A7sb,A8sb,... 227 | % 'RowNames',CodeName1) 228 | SingleWheelBond = [A1sb,A2sb,A3sb,A4sb,A5sb,A6sb,A7sb,A8sb] 229 | 230 | % Single wheel unbonded interface 1, bonded interface 2 231 | A1ss = [slip_single(:,1);sigz3s(1)]; 232 | A2ss = [slip_single(:,2);epsx3s(2)]; 233 | A3ss = [slip_single(:,3);epsz3s(3)]; 234 | A4ss = [slip_single(:,4);epsz3s(4)]; 235 | A5ss = [slip_single(:,5);sigz3s(5)]; 236 | A6ss = [slip_single(:,6);epsx3s(6)]; 237 | A7ss = [slip_single(:,7);epsz3s(7)]; 238 | A8ss = [slip_single(:,8);epsz3s(8)]; 239 | %SingleWheelSlip = table(A1ss,A2ss,A3ss,A4ss,A5ss,A6ss,A7ss,A8ss,... 240 | % 'RowNames',CodeName2) 241 | SingleWheelSlip = [A1ss,A2ss,A3ss,A4ss,A5ss,A6ss,A7ss,A8ss] 242 | 243 | % Dual wheel bonded interfaces 244 | A1db = [bond_dual(:,1);sigz2d(1);sigz1d(1)]; 245 | A2db = [bond_dual(:,2);epsy2d(2);epsy1d(2)]; 246 | A3db = [bond_dual(:,3);epsz2d(3);epsz1d(3)]; 247 | A4db = [bond_dual(:,4);epsz2d(4);epsz1d(4)]; 248 | A5db = [bond_dual(:,5);sigz2d(5);sigz1d(5)]; 249 | A6db = [bond_dual(:,6);epsy2d(6);epsy1d(6)]; 250 | A7db = [bond_dual(:,7);epsz2d(7);epsz1d(7)]; 251 | A8db = [bond_dual(:,8);epsz2d(8);epsz1d(8)]; 252 | %DualWheelBond = table(A1db,A2db,A3db,A4db,A5db,A6db,A7db,A8db,... 253 | % 'RowNames',CodeName1) 254 | DualWheelBond = [A1db,A2db,A3db,A4db,A5db,A6db,A7db,A8db] 255 | 256 | % Dual wheel unbonded interface 1, bonded interface 2 257 | A1ds = [slip_dual(:,1);sigz3d(1)]; 258 | A2ds = [slip_dual(:,2);epsy3d(2)]; 259 | A3ds = [slip_dual(:,3);epsz3d(3)]; 260 | A4ds = [slip_dual(:,4);epsz3d(4)]; 261 | A5ds = [slip_dual(:,5);sigz3d(5)]; 262 | A6ds = [slip_dual(:,6);epsy3d(6)]; 263 | A7ds = [slip_dual(:,7);epsz3d(7)]; 264 | A8ds = [slip_dual(:,8);epsz3d(8)]; 265 | %DualWheelSlip = table(A1ds,A2ds,A3ds,A4ds,A5ds,A6ds,A7ds,A8ds,... 266 | % 'RowNames',CodeName2) 267 | DualWheelSlip = [A1ds,A2ds,A3ds,A4ds,A5ds,A6ds,A7ds,A8ds] 268 | -------------------------------------------------------------------------------- /basic/arb_func_plain.m: -------------------------------------------------------------------------------- 1 | function ABCD = arb_func_plain(n,m,zi,E,nu,alva) 2 | 3 | %-------------------------------------------------------------------------- 4 | % DESCRIPTION: 5 | % This function evaluates the coefficients of integration Ai, Bi, Ci and Di 6 | % of each layer. These are unitless functions that embody the layered 7 | % system properties and connectivity. 8 | 9 | % INPUT PARAMETERS 10 | % n : Number of layers (including half space layer) 11 | % m : Integration parameters 12 | % zi : Distance from surface to the bottom of each layer 13 | % E : Layer Young's moduli 14 | % nu : Layer Poissons ratio's 15 | % bond : Interface bonding type 16 | %-------------------------------------------------------------------------- 17 | 18 | % Number of integration points 19 | Lm = length(m); % Lm = Length of m 20 | ONES = ones(1,Lm); 21 | 22 | % Evaluate the parameters ABCD 23 | H = zi(end); % Depth to the upper boundary of the 24 | % inifnite (bottom) layer from the top 25 | % surface 26 | lam = [0 zi max(zi)*1e20]'/H; % Number of lambda values correspond to 27 | % the number of layer interfaces (including 28 | % the surface of the top layer). We have 29 | % added a infinite value (1e20*max(zi)) in 30 | % the last place. But it will not influence 31 | % on the outcome, since it will only be 32 | % used in the last A and C coefficients 33 | % equations which are remmoved from the 34 | % system of equations before solved, since 35 | % these A and C values are zero. These two 36 | % equations are however organized, as it is 37 | % easier to do in the loop instead of 38 | % having a special case at the end. 39 | 40 | % lam = [lam0 lam1 lam2 ... lam_n-1 0] = [z0 z1 z2 ... z_n-1 0]/H 41 | % I.e. lami = lam(i+1) 42 | 43 | % Make sure that E and nu are "standing" vectors in order for the 44 | % multiplications below to be correct 45 | if size(E,1) < size(E,2) 46 | E = E'; 47 | end 48 | 49 | if size(nu,1) < size(nu,2) 50 | nu = nu'; 51 | end 52 | 53 | if length(zi) > length(E) 54 | display('The length of zi is too high or the length of E is to short') 55 | end 56 | %-------------------------------------------------------------------------- 57 | % Setup the boundary and continuity conditions 58 | %-------------------------------------------------------------------------- 59 | % Define the i and j-coordinates 60 | j = 1:n-1; 61 | i = j+1; 62 | 63 | % Define the equations 64 | 65 | % Equations based on the vertical stresses 66 | sigmaz = [ ... 67 | 1*ones(n-1,1)*ONES ... % Ai 68 | exp(-(lam(i)-lam(i-1))*m) ... % Bi 69 | -(1-2*nu(j)*ONES-lam(i)*m) ... % Ci 70 | (1-2*nu(j)*ONES+lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 71 | -exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 72 | -1*ones(n-1,1)*ONES ... % B{i+1} 73 | (1-2*nu(j+1)*ONES-lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 74 | -(1-2*nu(j+1)*ONES+lam(i)*m) ... % D{i+1} 75 | ]; 76 | 77 | % Equations based on the shear stresses 78 | taurz = [ ... 79 | 1*ones(n-1,1)*ONES ... % Ai 80 | -exp(-(lam(i)-lam(i-1))*m) ... % Bi 81 | (2*nu(j)*ONES+lam(i)*m) ... % Ci 82 | (2*nu(j)*ONES-lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 83 | -exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 84 | 1*ones(n-1,1)*ONES ... % B{i+1} 85 | -(2*nu(j+1)*ONES+lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 86 | -(2*nu(j+1)*ONES-lam(i)*m) ... % D{i+1} 87 | ]; 88 | 89 | if strcmp(alva.bond,'Frictionless') 90 | taurz1 = [ ... 91 | 1*ones(n-1,1)*ONES ... % Ai 92 | -exp(-(lam(i)-lam(i-1))*m) ... % Bi 93 | (2*nu(j)*ONES+lam(i)*m) ... % Ci 94 | (2*nu(j)*ONES-lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 95 | -exp(-(lam(i+1)-lam(i))*m).*0 ... % A{i+1} 96 | 1*ones(n-1,1)*ONES.*0 ... % B{i+1} 97 | -(2*nu(j+1)*ONES+lam(i)*m).*exp(-(lam(i+1)-lam(i))*m).*0 ... % C{i+1} 98 | -(2*nu(j+1)*ONES-lam(i)*m).*0 ... % D{i+1} 99 | ]; 100 | taurz2 = [ ... 101 | 1*ones(n-1,1)*ONES.*0 ... % Ai 102 | -exp(-(lam(i)-lam(i-1))*m).*0 ... % Bi 103 | (2*nu(j)*ONES+lam(i)*m).*0 ... % Ci 104 | (2*nu(j)*ONES-lam(i)*m).*exp(-(lam(i)-lam(i-1))*m).*0 ... % Di 105 | -exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 106 | 1*ones(n-1,1)*ONES ... % B{i+1} 107 | -(2*nu(j+1)*ONES+lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 108 | -(2*nu(j+1)*ONES-lam(i)*m) ... % D{i+1} 109 | ]; 110 | end 111 | 112 | % Equations based on the vertical displacements 113 | uz = [ ... 114 | (1+nu(j))./E(j)*ONES ... % Ai 115 | -(1+nu(j))./E(j)*ONES.*exp(-(lam(i)-lam(i-1))*m) ... % Bi 116 | -(1+nu(j))./E(j)*ONES.*(2-4*nu(j)*ONES-lam(i)*m) ... % Ci 117 | -(1+nu(j))./E(j)*ONES.*(2-4*nu(j)*ONES+lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 118 | -(1+nu(j+1))./E(j+1)*ONES.*exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 119 | (1+nu(j+1))./E(j+1)*ONES ... % B{i+1} 120 | (1+nu(j+1))./E(j+1)*ONES.*(2-4*nu(j+1)*ONES-lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 121 | (1+nu(j+1))./E(j+1)*ONES.*(2-4*nu(j+1)*ONES+lam(i)*m) ... % D{i+1} 122 | ]; 123 | 124 | % Equations based on the radial displacements 125 | ur = [ ... 126 | (1+nu(j))./E(j)*ONES ... % Ai 127 | (1+nu(j))./E(j)*ONES.*exp(-(lam(i)-lam(i-1))*m) ... % Bi 128 | (1+nu(j))./E(j)*ONES.*(1+lam(i)*m) ... % Ci 129 | -(1+nu(j))./E(j)*ONES.*(1-lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 130 | -(1+nu(j+1))./E(j+1)*ONES.*exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 131 | -(1+nu(j+1))./E(j+1)*ONES ... % B{i+1} 132 | -(1+nu(j+1))./E(j+1)*ONES.*(1+lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 133 | (1+nu(j+1))./E(j+1)*ONES.*(1-lam(i)*m) ... % D{i+1} 134 | ]; 135 | 136 | if strcmp(alva.bond,'Slip') 137 | kh = alva.kh; 138 | if size(kh,1) < size(kh,2) 139 | kh = kh'; 140 | end 141 | ur = [ ... 142 | -kh(j).*(H./m).*(1+nu(j))./E(j)-1*ones(n-1,1)*ONES ... % Ai 143 | (1*ones(n-1,1)*ONES - kh(j).*(H./m).*(1+nu(j))./E(j)).*exp(-(lam(i)-lam(i-1))*m) ... % Bi 144 | -kh(j).*(H./m).*(1+nu(j))./E(j).*(1+lam(i)*m)-(2*nu(j)*ONES+lam(i)*m) ... % Ci 145 | (kh(j).*(H./m).*(1+nu(j))./E(j).*(1-lam(i)*m)-(2*nu(j)*ONES-lam(i)*m)).*exp(-(lam(i)-lam(i-1))*m) ... % Di 146 | kh(j).*(H./m).*(1+nu(j+1))./E(j+1).*exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 147 | kh(j).*(H./m).*(1+nu(j+1))./E(j+1) ... % B{i+1} 148 | kh(j).*(H./m).*(1+nu(j+1))./E(j+1).*(lam(i)*m+1).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 149 | kh(j).*(H./m).*(1+nu(j+1))./E(j+1).*(lam(i)*m-1) ... % D{i+1} 150 | ]; 151 | end 152 | 153 | % Arrange the set of linear matrix system to solve for the parameters Ai, 154 | % Bi, Ci and Di 155 | % Surface boundary conditions 156 | BC0 = [exp(-m*(lam(2)-lam(1))) 1*ONES -(1-2*nu(1))*exp(-m*(lam(2)-lam(1))) (1-2*nu(1))*ONES spalloc(1,4*Lm,0); % lam(2) = lam1, nu(1) = nu1 157 | exp(-m*(lam(2)-lam(1))) -1*ONES 2*nu(1)*exp(-m*(lam(2)-lam(1))) 2*nu(1)*ONES spalloc(1,4*Lm,0)]; 158 | 159 | % All conditions in the intermediate layers 160 | BCs = [sigmaz 161 | taurz 162 | uz 163 | ur ]; 164 | 165 | if strcmp(alva.bond,'Frictionless') 166 | BCs = [sigmaz 167 | uz 168 | taurz1 169 | taurz2]; 170 | end 171 | 172 | % When inserting m in order to evaluate BC0 and BCs (=BC), the first 173 | % Lm = length(m) columns of BC0 will be exp(-m.*...) with different m 174 | % values. The following Lm columns will contain 1 and -1. We want to 175 | % reorganize such that the first columns contains the equations 176 | % in BC0 with m(1), the following columns correspond to the equations 177 | % in BC0 with the m(2) value etc., i.e., we want to go from 178 | % BC0 = [exp(-m(1).*...) exp(-m(2).*...) exp(-m(3).*...) .. ] 179 | % to 180 | % BC0 = [exp(-m(1).*...) 1 -(1-2*nu(1))*exp(-m(1)...) .. ] 181 | 182 | % The same reorganization we want to do with the BCs matrix 183 | % Vectors used to change the the column sequence are denoted indx_c 184 | 185 | % indx(:)' = [0 0 0 .. 1 1 1 .. 2 2 2 .. Lm-1 Lm-1 Lm-1]: 186 | % 8 = number of equations (=columns) in BCs for one m-value 187 | indx_c = repmat(0:Lm-1,8,1); 188 | indx_c = repmat(1:Lm:(8-1)*Lm+1,1,Lm) + indx_c(:)'; 189 | 190 | % Also the rows of BCs should be reorganized in order for the lambda, nu 191 | % and E-values to be in the correct sequence. The index vector for this is 192 | % denoted indx_r and is defined as 193 | indx_r = [1:n-1 ; n:2*(n-1) ; 2*n-1:3*(n-1) ; 3*n-2:4*(n-1)]; 194 | 195 | % Use indx_c and indx_r to reorganice BCs and BC0 and order them in a 196 | % united matrix BC. Only the rows of BCs are to be reorganized. BC0 is fine. 197 | BC = [BC0(:,indx_c); BCs(indx_r(:),indx_c)]; 198 | 199 | % Now we have a matrix BC that contains all the coefficients for each 200 | % integration point. BC has 4*n-2 rows (corresponding to the number of 201 | % unknowns) and 4*n (the number of unknowns plus 2 - later we reduce this 202 | % to 4*n-2) columns per integration point, i.e. 4*n*Lm columns in 203 | % total. Each (4*n-2) x 4*n - referred to as a submatrix, that only 204 | % represents a single integration point. We want to organize all submatrices 205 | % in a diagonal matrix of dimension Lm*(4*n-2) x 4*n*Lm, with each submatrix 206 | % decoupled from the others. 207 | 208 | % Below and indx vector that inserts the first submatrix in BC into the 209 | % right positions in BCg is organized. The way to use indx is in the 210 | % following way: BCg(indx) = BC(:) 211 | 212 | % indx for a single submatrix - step 1 of 5 213 | indx = repmat(1:(4*n-2),8,1)'; % Indices on all cells in a single matrix. 214 | % We have (4*n-2)*8 coefficients in a single 215 | % sub matrix to fill in into the global matrix 216 | 217 | % Additional content to indx is given (step 2 of 5). Two vectors a and c are 218 | % defined 219 | a = repmat(0:7,4*n-2,1); 220 | c = repmat(0:4:4*(n-2),4,1); 221 | c = repmat([zeros(2,1) ; c(:)],8,1); 222 | 223 | % Add vectors a and c to indx (step 3 of 5) - the content of indx will then 224 | % represent the indeces for the first submatrix in the BCs matrix for a 225 | % single submatrix (the first one only) 226 | indx = indx(:) + (a(:)+c)*(4*n-2)*Lm; 227 | 228 | % Now indx is expanded to consider all Lm submatrices. A vector b is 229 | % organized (step 4 of 5) 230 | b = repmat([0 1:Lm-1],length(indx),1); 231 | 232 | % Organize indx for all submatrices (step 5 of 5) 233 | indx = repmat(indx,Lm,1) + b(:)*(4*n*Lm+1)*(4*n-2); 234 | 235 | % Insert BC content into BCg in the right positions 236 | % tic 237 | % BCg(indx) = BC; % corresponds to BCg(indx) = BC(:) 238 | % time_BCg=toc 239 | 240 | % Indices to subindeces 241 | [I,J] = ind2sub([Lm*(4*n-2) 4*n*Lm],indx); 242 | BCg = sparse(I,J,BC,Lm*(4*n-2),4*n*Lm); 243 | 244 | % We now need to remove the the columns corresponding to the coefficients 245 | % An and Cn from each submatrix in BCg. The vector for this is denoted 246 | % indx_cr and is defined as 247 | indx_cr = [4*n-3:4*n:4*n*Lm-3; 4*n-1:4*n:4*n*Lm-1]; 248 | 249 | % Remove the columns 250 | BCg(:,indx_cr) = []; 251 | 252 | % Now we need to organize the external load vector. (use repmat for this) 253 | 254 | % Define right-hand side of equations 255 | Rhs = [1; spalloc(4*n-3,1,1)]; 256 | Rhs = repmat(Rhs,Lm,1); 257 | 258 | % Evaluate A, B, C and D coefficients from the equation BCg*[A B C D ...]' 259 | % = Rhs 260 | ABCD0 = BCg\Rhs; 261 | 262 | % Redefine ABCD so that each column represents an integration point. 263 | % Furthermore zero values are introduced for A and C (which are needed to 264 | % generalize the evaluations of sigma and u's in a simple way) 265 | % ABCD = reorganize size 266 | ABCD = zeros(4*n-2,Lm); % Organize zero vector with two additinal 267 | % inputs compared to ABCD0 268 | ABCD(:) = ABCD0; 269 | ABCD = [ABCD(1:end-2,:) % [A1, B1, C1, D1, A2, B2 , .... , D{n-1}] 270 | spalloc(1,Lm,0) % An = 0 271 | ABCD(end-1,:) % Bn 272 | spalloc(1,Lm,0) % Cn = 0 273 | ABCD(end,:) ]; % Dn -------------------------------------------------------------------------------- /basic/arb_func.m: -------------------------------------------------------------------------------- 1 | function ABCD = arb_func(n,zi,E,nu,alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function evaluates the coefficients of integration Ai, Bi, Ci and Di 5 | % of each layer. These are unitless functions that embody the layered 6 | % system properties and connectivity. 7 | 8 | % INPUT PARAMETERS 9 | % n : Number of layers (including half space layer) 10 | % zi : Distance from surface to the bottom of each layer 11 | % E : Layer Young's moduli 12 | % nu : Layer Poissons ratio's 13 | % bond : Interface bonding type 14 | %-------------------------------------------------------------------------- 15 | 16 | % In order to speed the computational time, the number of matrix inversions 17 | % is limited to 96, corresponding to 96 predetermined values of the 18 | % integration variable m in the range of 0 to 100,000, as follows: 19 | m = [1e-10, 0.05, 0.10, 0.20, 0.40, 0.60, 0.80, 1.00, 1.20, 1.40, 1.60,... 20 | 1.80, 2.00, 2.20, 2.40, 2.60, 2.80, 3.00, 3.20, 3.40, 3.60, 3.80,... 21 | 4.00, 4.20, 4.40, 4.60, 4.80, 5.00, 5.50, 6.00, 6.50, 7.00, 7.50,... 22 | 8.00, 8.50, 9.00, 9.50, 10.00, 11.00, 12.00, 13.00, 14.00, 15.00,... 23 | 16.00, 17.00, 18.00, 19.00, 20.00, 25.00, 30.00, 35.00, 40.00,... 24 | 45.00, 50.00, 55.00, 60.00, 65.00, 70.00, 75.00, 80.00, 85.00,... 25 | 90.00, 95.00, 100.00, 110.00, 120.00, 130.00, 140.00, 150.00,... 26 | 160.00, 170.00, 180.00, 190.00, 200.00, 210.00, 220.00, 230.00,... 27 | 240.00, 250.00, 260.00, 270.00, 280.00, 290.00, 300.00, 350.00,... 28 | 400.00, 450.00, 500.00, 600.00, 700.00, 800.00, 900.00, 1000.00,... 29 | 2000.00, 10000.00, 100000.00]; 30 | 31 | % Number of integration points 32 | Lm = length(m); % Lm = Length of m 33 | ONES = ones(1,Lm); 34 | 35 | % Evaluate the parameters ABCD 36 | H = zi(end); % Depth to the upper boundary of the 37 | % inifnite (bottom) layer from the top 38 | % surface 39 | lam = [0 zi max(zi)*1e20]'/H; % Number of lambda values correspond to 40 | % the number of layer interfaces (including 41 | % the surface of the top layer). We have 42 | % added a infinite value (1e20*max(zi)) in 43 | % the last place. But it will not influence 44 | % on the outcome, since it will only be 45 | % used in the last A and C coefficients 46 | % equations which are remmoved from the 47 | % system of equations before solved, since 48 | % these A and C values are zero. These two 49 | % equations are however organized, as it is 50 | % easier to do in the loop instead of 51 | % having a special case at the end. 52 | 53 | % lam = [lam0 lam1 lam2 ... lam_n-1 0] = [z0 z1 z2 ... z_n-1 0]/H 54 | % I.e. lami = lam(i+1) 55 | 56 | % Make sure that E and nu are "standing" vectors in order for the 57 | % multiplications below to be correct 58 | if size(E,1) < size(E,2) 59 | E = E'; 60 | end 61 | 62 | if size(nu,1) < size(nu,2) 63 | nu = nu'; 64 | end 65 | 66 | if length(zi) > length(E) 67 | display('The length of zi is too high or the length of E is to short') 68 | end 69 | %-------------------------------------------------------------------------- 70 | % Setup the boundary and continuity conditions 71 | %-------------------------------------------------------------------------- 72 | % Define the i and j-coordinates 73 | j = 1:n-1; 74 | i = j+1; 75 | 76 | % Define the equations 77 | 78 | % Equations based on the vertical stresses 79 | sigmaz = [ ... 80 | 1*ones(n-1,1)*ONES ... % Ai 81 | exp(-(lam(i)-lam(i-1))*m) ... % Bi 82 | -(1-2*nu(j)*ONES-lam(i)*m) ... % Ci 83 | (1-2*nu(j)*ONES+lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 84 | -exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 85 | -1*ones(n-1,1)*ONES ... % B{i+1} 86 | (1-2*nu(j+1)*ONES-lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 87 | -(1-2*nu(j+1)*ONES+lam(i)*m) ... % D{i+1} 88 | ]; 89 | 90 | % Equations based on the shear stresses 91 | taurz = [ ... 92 | 1*ones(n-1,1)*ONES ... % Ai 93 | -exp(-(lam(i)-lam(i-1))*m) ... % Bi 94 | (2*nu(j)*ONES+lam(i)*m) ... % Ci 95 | (2*nu(j)*ONES-lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 96 | -exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 97 | 1*ones(n-1,1)*ONES ... % B{i+1} 98 | -(2*nu(j+1)*ONES+lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 99 | -(2*nu(j+1)*ONES-lam(i)*m) ... % D{i+1} 100 | ]; 101 | 102 | if strcmp(alva.bond,'Frictionless') 103 | taurz1 = [ ... 104 | 1*ones(n-1,1)*ONES ... % Ai 105 | -exp(-(lam(i)-lam(i-1))*m) ... % Bi 106 | (2*nu(j)*ONES+lam(i)*m) ... % Ci 107 | (2*nu(j)*ONES-lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 108 | -exp(-(lam(i+1)-lam(i))*m).*0 ... % A{i+1} 109 | 1*ones(n-1,1)*ONES.*0 ... % B{i+1} 110 | -(2*nu(j+1)*ONES+lam(i)*m).*exp(-(lam(i+1)-lam(i))*m).*0 ... % C{i+1} 111 | -(2*nu(j+1)*ONES-lam(i)*m).*0 ... % D{i+1} 112 | ]; 113 | taurz2 = [ ... 114 | 1*ones(n-1,1)*ONES.*0 ... % Ai 115 | -exp(-(lam(i)-lam(i-1))*m).*0 ... % Bi 116 | (2*nu(j)*ONES+lam(i)*m).*0 ... % Ci 117 | (2*nu(j)*ONES-lam(i)*m).*exp(-(lam(i)-lam(i-1))*m).*0 ... % Di 118 | -exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 119 | 1*ones(n-1,1)*ONES ... % B{i+1} 120 | -(2*nu(j+1)*ONES+lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 121 | -(2*nu(j+1)*ONES-lam(i)*m) ... % D{i+1} 122 | ]; 123 | end 124 | 125 | % Equations based on the vertical displacements 126 | uz = [ ... 127 | (1+nu(j))./E(j)*ONES ... % Ai 128 | -(1+nu(j))./E(j)*ONES.*exp(-(lam(i)-lam(i-1))*m) ... % Bi 129 | -(1+nu(j))./E(j)*ONES.*(2-4*nu(j)*ONES-lam(i)*m) ... % Ci 130 | -(1+nu(j))./E(j)*ONES.*(2-4*nu(j)*ONES+lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 131 | -(1+nu(j+1))./E(j+1)*ONES.*exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 132 | (1+nu(j+1))./E(j+1)*ONES ... % B{i+1} 133 | (1+nu(j+1))./E(j+1)*ONES.*(2-4*nu(j+1)*ONES-lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 134 | (1+nu(j+1))./E(j+1)*ONES.*(2-4*nu(j+1)*ONES+lam(i)*m) ... % D{i+1} 135 | ]; 136 | 137 | % Equations based on the radial displacements 138 | ur = [ ... 139 | (1+nu(j))./E(j)*ONES ... % Ai 140 | (1+nu(j))./E(j)*ONES.*exp(-(lam(i)-lam(i-1))*m) ... % Bi 141 | (1+nu(j))./E(j)*ONES.*(1+lam(i)*m) ... % Ci 142 | -(1+nu(j))./E(j)*ONES.*(1-lam(i)*m).*exp(-(lam(i)-lam(i-1))*m) ... % Di 143 | -(1+nu(j+1))./E(j+1)*ONES.*exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 144 | -(1+nu(j+1))./E(j+1)*ONES ... % B{i+1} 145 | -(1+nu(j+1))./E(j+1)*ONES.*(1+lam(i)*m).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 146 | (1+nu(j+1))./E(j+1)*ONES.*(1-lam(i)*m) ... % D{i+1} 147 | ]; 148 | 149 | if strcmp(alva.bond,'Slip') 150 | kh = alva.kh; 151 | if size(kh,1) < size(kh,2) 152 | kh = kh'; 153 | end 154 | ur = [ ... 155 | -kh(j).*(H./m).*(1+nu(j))./E(j)-1*ones(n-1,1)*ONES ... % Ai 156 | (1*ones(n-1,1)*ONES - kh(j).*(H./m).*(1+nu(j))./E(j)).*exp(-(lam(i)-lam(i-1))*m) ... % Bi 157 | -kh(j).*(H./m).*(1+nu(j))./E(j).*(1+lam(i)*m)-(2*nu(j)*ONES+lam(i)*m) ... % Ci 158 | (kh(j).*(H./m).*(1+nu(j))./E(j).*(1-lam(i)*m)-(2*nu(j)*ONES-lam(i)*m)).*exp(-(lam(i)-lam(i-1))*m) ... % Di 159 | kh(j).*(H./m).*(1+nu(j+1))./E(j+1).*exp(-(lam(i+1)-lam(i))*m) ... % A{i+1} 160 | kh(j).*(H./m).*(1+nu(j+1))./E(j+1) ... % B{i+1} 161 | kh(j).*(H./m).*(1+nu(j+1))./E(j+1).*(lam(i)*m+1).*exp(-(lam(i+1)-lam(i))*m) ... % C{i+1} 162 | kh(j).*(H./m).*(1+nu(j+1))./E(j+1).*(lam(i)*m-1) ... % D{i+1} 163 | ]; 164 | end 165 | 166 | % Arrange the set of linear matrix system to solve for the parameters Ai, 167 | % Bi, Ci and Di 168 | % Surface boundary conditions 169 | BC0 = [exp(-m*(lam(2)-lam(1))) 1*ONES -(1-2*nu(1))*exp(-m*(lam(2)-lam(1))) (1-2*nu(1))*ONES spalloc(1,4*Lm,0); % lam(2) = lam1, nu(1) = nu1 170 | exp(-m*(lam(2)-lam(1))) -1*ONES 2*nu(1)*exp(-m*(lam(2)-lam(1))) 2*nu(1)*ONES spalloc(1,4*Lm,0)]; 171 | 172 | % All conditions in the intermediate layers 173 | BCs = [sigmaz 174 | taurz 175 | uz 176 | ur ]; 177 | 178 | if strcmp(alva.bond,'Frictionless') 179 | BCs = [sigmaz 180 | uz 181 | taurz1 182 | taurz2]; 183 | end 184 | 185 | % When inserting m in order to evaluate BC0 and BCs (=BC), the first 186 | % Lm = length(m) columns of BC0 will be exp(-m.*...) with different m 187 | % values. The following Lm columns will contain 1 and -1. We want to 188 | % reorganize such that the first columns contains the equations 189 | % in BC0 with m(1), the following columns correspond to the equations 190 | % in BC0 with the m(2) value etc., i.e., we want to go from 191 | % BC0 = [exp(-m(1).*...) exp(-m(2).*...) exp(-m(3).*...) .. ] 192 | % to 193 | % BC0 = [exp(-m(1).*...) 1 -(1-2*nu(1))*exp(-m(1)...) .. ] 194 | 195 | % The same reorganization we want to do with the BCs matrix 196 | % Vectors used to change the the column sequence are denoted indx_c 197 | 198 | % indx(:)' = [0 0 0 .. 1 1 1 .. 2 2 2 .. Lm-1 Lm-1 Lm-1]: 199 | % 8 = number of equations (=columns) in BCs for one m-value 200 | indx_c = repmat(0:Lm-1,8,1); 201 | indx_c = repmat(1:Lm:(8-1)*Lm+1,1,Lm) + indx_c(:)'; 202 | 203 | % Also the rows of BCs should be reorganized in order for the lambda, nu 204 | % and E-values to be in the correct sequence. The index vector for this is 205 | % denoted indx_r and is defined as 206 | indx_r = [1:n-1 ; n:2*(n-1) ; 2*n-1:3*(n-1) ; 3*n-2:4*(n-1)]; 207 | 208 | % Use indx_c and indx_r to reorganice BCs and BC0 and order them in a 209 | % united matrix BC. Only the rows of BCs are to be reorganized. BC0 is fine. 210 | BC = [BC0(:,indx_c); BCs(indx_r(:),indx_c)]; 211 | 212 | % Now we have a matrix BC that contains all the coefficients for each 213 | % integration point. BC has 4*n-2 rows (corresponding to the number of 214 | % unknowns) and 4*n (the number of unknowns plus 2 - later we reduce this 215 | % to 4*n-2) columns per integration point, i.e. 4*n*Lm columns in 216 | % total. Each (4*n-2) x 4*n - referred to as a submatrix, that only 217 | % represents a single integration point. We want to organize all submatrices 218 | % in a diagonal matrix of dimension Lm*(4*n-2) x 4*n*Lm, with each submatrix 219 | % decoupled from the others. 220 | 221 | % Below and indx vector that inserts the first submatrix in BC into the 222 | % right positions in BCg is organized. The way to use indx is in the 223 | % following way: BCg(indx) = BC(:) 224 | 225 | % indx for a single submatrix - step 1 of 5 226 | indx = repmat(1:(4*n-2),8,1)'; % Indices on all cells in a single matrix. 227 | % We have (4*n-2)*8 coefficients in a single 228 | % sub matrix to fill in into the global matrix 229 | 230 | % Additional content to indx is given (step 2 of 5). Two vectors a and c are 231 | % defined 232 | a = repmat(0:7,4*n-2,1); 233 | c = repmat(0:4:4*(n-2),4,1); 234 | c = repmat([zeros(2,1) ; c(:)],8,1); 235 | 236 | % Add vectors a and c to indx (step 3 of 5) - the content of indx will then 237 | % represent the indeces for the first submatrix in the BCs matrix for a 238 | % single submatrix (the first one only) 239 | indx = indx(:) + (a(:)+c)*(4*n-2)*Lm; 240 | 241 | % Now indx is expanded to consider all Lm submatrices. A vector b is 242 | % organized (step 4 of 5) 243 | b = repmat([0 1:Lm-1],length(indx),1); 244 | 245 | % Organize indx for all submatrices (step 5 of 5) 246 | indx = repmat(indx,Lm,1) + b(:)*(4*n*Lm+1)*(4*n-2); 247 | 248 | % Insert BC content into BCg in the right positions 249 | % tic 250 | % BCg(indx) = BC; % corresponds to BCg(indx) = BC(:) 251 | % time_BCg=toc 252 | 253 | % Indices to subindeces 254 | [I,J] = ind2sub([Lm*(4*n-2) 4*n*Lm],indx); 255 | BCg = sparse(I,J,BC,Lm*(4*n-2),4*n*Lm); 256 | 257 | % We now need to remove the the columns corresponding to the coefficients 258 | % An and Cn from each submatrix in BCg. The vector for this is denoted 259 | % indx_cr and is defined as 260 | indx_cr = [4*n-3:4*n:4*n*Lm-3; 4*n-1:4*n:4*n*Lm-1]; 261 | 262 | % Remove the columns 263 | BCg(:,indx_cr) = []; 264 | 265 | % Now we need to organize the external load vector. (use repmat for this) 266 | 267 | % Define right-hand side of equations 268 | Rhs = [1; spalloc(4*n-3,1,1)]; 269 | Rhs = repmat(Rhs,Lm,1); 270 | 271 | % Evaluate A, B, C and D coefficients from the equation BCg*[A B C D ...]' 272 | % = Rhs 273 | ABCD0 = BCg\Rhs; 274 | 275 | % Redefine ABCD so that each column represents an integration point. 276 | % Furthermore zero values are introduced for A and C (which are needed to 277 | % generalize the evaluations of sigma and u's in a simple way) 278 | % ABCD = reorganize size 279 | ABCD = zeros(4*n-2,Lm); % Organize zero vector with two additinal 280 | % inputs compared to ABCD0 281 | ABCD(:) = ABCD0; 282 | ABCD = [ABCD(1:end-2,:) % [A1, B1, C1, D1, A2, B2 , .... , D{n-1}] 283 | spalloc(1,Lm,0) % An = 0 284 | ABCD(end-1,:) % Bn 285 | spalloc(1,Lm,0) % Cn = 0 286 | ABCD(end,:) ]; % Dn 287 | 288 | % Output A, B, C and D for all layers with m point as last row. To be used 289 | % for interpolation at later stage. 290 | ABCD = full(ABCD); 291 | ABCD = [ABCD; m]; -------------------------------------------------------------------------------- /basic/LET_response_plain.m: -------------------------------------------------------------------------------- 1 | function alva = LET_response_plain(alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function evaluates the response of a layered elastic half-space 5 | % model utilizing Linear Elastic Theory (LET) [2]. 6 | 7 | % INPUT PARAMETERS: 8 | Xd = alva.Xd; % Output coordinates (x,y,z) 9 | Xl = alva.Xl; % Load posistion coordinates (x,y) 10 | a = alva.a; % Load radii 11 | q = alva.q; % Load pressure 12 | E = alva.E; % Layer Young's moduli 13 | nu = alva.nu; % Layer Poisson's ratios 14 | zi = alva.zi; % Layer interface depths (i.e. depth of layer n-1 out 15 | % of n layers (layer n depth goes to infinity) 16 | XipWip = alva.XipWip; % Integration points and weights used in integration 17 | ABCD = alva.ABCD; % Coefficients of integration 18 | 19 | % ------------------------------------------------------------------------- 20 | % References 21 | % ------------------------------------------------------------------------- 22 | %[2] Burmister. (1945). The general theory of stresses and displacements 23 | % in layered systems. I-iii. Journal of Applied Physics, 16, 89–94, 89–94. 24 | % ------------------------------------------------------------------------- 25 | 26 | % If zi has more entries than length(E)-1, these are removed. In principle 27 | % the last entry in zi is infinite. However, the infinite value is not 28 | % included in this code, as we do not operate with infinite number. We 29 | % handle this in an optional way. 30 | if length(zi) <= length(E) 31 | zi(length(E):end) = []; 32 | end 33 | 34 | % The code is organized such that we need a minimum of 2 layers! Check if 35 | % zi has at least one value 36 | if isempty(zi) 37 | disp('the code is arranged such that we need minimum two layers!!') 38 | end 39 | 40 | % Define depth of layer n-1 out of n layers (layer n depth goes to infinity) 41 | H = zi(end); 42 | 43 | % Check if the length of E and nu are equal 44 | if length(E) ~= length(nu) 45 | disp('length(E) ~= length(nu) !!!') 46 | end 47 | 48 | % Number of loads (xl) and deformation points (xd) 49 | xl = size(Xl,1); % Number of load points 50 | xd = size(Xd,1); % Number of deformation points 51 | 52 | % Make sure that the length of q and a are correct. These should be equal 53 | % to the number of loads. 54 | if length(q) < xl || length(a) < xl 55 | disp('Number of q and/or a values is lower than the number of load coordinates (= number of loads), so all loads are given the same q- and a-values') 56 | q = q(1)*ones(xl,1); 57 | a = a(1)*ones(xl,1); 58 | end 59 | 60 | % Make sure that q and a are vectors "standing up" 61 | if size(q,1) < size(q,2) 62 | q = q'; 63 | end 64 | 65 | if size(a,1) < size(a,2) 66 | a = a'; 67 | end 68 | 69 | % Make sure that zi is a 'horizontal' vector 70 | if size(zi,1) > size(zi,2) 71 | zi = zi'; 72 | end 73 | 74 | % Increase Xl, q, alpha, Xd and z in order to estimate the radius from each 75 | % of the loads to all of the points. The number of radii are: xl*xd 76 | Xl = repmat(Xl,[xd,1]); % Extends with the number of evaluation 77 | % points 78 | q = repmat(q,[xd,1]); % -||- 79 | alpha = repmat(a/H,[xd,1]); % -||- 80 | Xd = repmat(Xd,[xl,1]); % -||- <-- is reorganized below to 81 | % correspond to the right Xl content/sequence 82 | 83 | % Reorganize Xd so the first xl rows correspond to the same deformation 84 | % point, and following xl rows correspond to the next deformation point 85 | % etc... see description of the vector r nine lines below to understand the 86 | % organization 87 | 88 | % Built dx vector used to reorganize/sort Xd in the right order 89 | dx = repmat(1:xd,xl,1); 90 | dx = dx(:)' + repmat(0:xd:xd*(xl-1),1,xd); 91 | Xd = Xd(dx,:); 92 | z = Xd(:,3); 93 | 94 | % Evaluate the radii between evaluation point and load 95 | % r = [ evaluation point 1 and load 1 96 | % evaluation point 1 and load 2 97 | % evaluation point 1 and load 3 98 | % . 99 | % evaluation point 1 and load N 100 | % evaluation point 2 and load 1 101 | % evaluation point 2 and load 2 102 | % . 103 | % . 104 | % last evaluation point and load N]; 105 | 106 | r = sqrt((Xd(:,1)-Xl(:,1)).^2 + (Xd(:,2)-Xl(:,2)).^2); 107 | 108 | % Introduce the parameter rho (notice: since r is a vector, rho is too) 109 | rho = r/H; 110 | rho(rho==0) = 1e-20; % insert a small value to avoid singularity in 111 | % calculation of stresses 112 | 113 | % Integration points and weights (takes out the length(rho) rows in XipWip 114 | % related to one load for one position) 115 | lrho = length(rho); % Number of load-to-displacement-points 116 | xip_z = XipWip(0*lrho+1:1*lrho,:); % takes out the first length(rho) rows 117 | wip_z = XipWip(1*lrho+1:2*lrho,:); % takes out next 118 | xip_r = XipWip(2*lrho+1:3*lrho,:); % etc... 119 | wip_r = XipWip(3*lrho+1:4*lrho,:); % etc... 120 | 121 | % Number of columns in reorganized integration points and weights (= number 122 | % of integration points per integral) 123 | nz = size(xip_z,2); 124 | 125 | % The depth z defines which E, nu, Ai, Bi, Ci and Di values should be used 126 | % in the different required evaluations of the response. A 127 | % horizontal vector called layer_no gives the information of which 128 | % values should be used. The length(layer_no) corresponds to the number of 129 | % radii, r, we have (i.e. the length of rho = r/H). 130 | 131 | % Layer number where the point we use is given* 132 | layer_no = sum(repmat(z,1,length(zi)) > repmat(zi,length(rho),1),2)'+1; 133 | 134 | % *Note: if (Xd,z) is larger than (zi,1) the function gives 1+1 135 | % = layer no. 2, if (Xd,z) is larger than (zi,2) the function gives 1+1+1 136 | % = layer no. 3 etc. 137 | 138 | Lami = zeros(length(rho),1); 139 | Lami1 = Lami; 140 | for i = 1:length(rho) % length(layer_no) = n3 141 | 142 | % Evaluate the lam_i value (if we are in the bottom layer, Lam_i=infinite) 143 | if layer_no(i) > length(zi) 144 | Lami(i) = zi(end)/H*1e20; % In principle Lami is multiplied by 145 | % A = 0 and C = 0 at the bottom layer, 146 | % and this value and will not have any 147 | % contribution 148 | else 149 | Lami(i) = zi(layer_no(i))/H; 150 | end 151 | 152 | % Evaluate the lam_{i-1} value (NB! lam_{0} = 0) 153 | if layer_no(i) == 1 % (= lam_{i-1} = lam{0}) 154 | Lami1(i) = 0; 155 | else 156 | Lami1(i) = zi(layer_no(i)-1)/H; 157 | end 158 | end 159 | 160 | % Evaluating response 161 | 162 | % Summation form 163 | % length(rho) = number of point to load radii, nz = number of integration 164 | % points in every point to load integral 165 | Aa = zeros(length(rho),nz); Bb = Aa; Cc = Aa; Dd = Aa; 166 | 167 | for j = 1:length(rho) % number of point to load radii 168 | % n in function below = number of layers = length(E) 169 | % m in function below = number of integration points = xip_z(j,:) 170 | 171 | ABCDz = arb_func_plain(length(E),xip_z(j,:),ABCD); 172 | 173 | % Select the relevant A, B, C and D values for the response points 174 | % considered 175 | Aa(j,:) = ABCDz((layer_no(j)-1)*4+1,:); 176 | Bb(j,:) = ABCDz((layer_no(j)-1)*4+2,:); 177 | Cc(j,:) = ABCDz((layer_no(j)-1)*4+3,:); 178 | Dd(j,:) = ABCDz((layer_no(j)-1)*4+4,:); 179 | end 180 | 181 | % Define E and Nu values for the layer considered for the evaluation of response 182 | Nu = nu(layer_no)'; 183 | Ee = E(layer_no)'; 184 | 185 | % Define exponential functions for one-step Richardson extrapolation 186 | x1 = 2^(-20); 187 | Iz1 = exp(-x1*xip_z.^2); 188 | Iz2 = exp(-(x1/2)*xip_z.^2); 189 | Ir1 = exp(-x1*xip_r.^2); 190 | Ir2 = exp(-(x1/2)*xip_r.^2); 191 | 192 | % ------------------------------------------------------------------------- 193 | % DISPLACEMENTS 194 | % ------------------------------------------------------------------------- 195 | % first part incl. J0: solved outside sum for all integration points 196 | % and then included inside sumation below 197 | 198 | %%%%% u_z %%%%% 199 | uzs = besselj(0,xip_z.*repmat(rho,1,nz)).*... 200 | (... 201 | (Aa-Cc.*(2-4*repmat(Nu,1,nz)-xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(Lami-z/H,1,nz))-... 202 | (Bb+Dd.*(2-4*repmat(Nu,1,nz)+xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(z/H-Lami1,1,nz))... 203 | ); 204 | 205 | % Improve the convergence for points residing close to the surface 206 | Iuz1 = q.*alpha.*(-1)*H.*(1+Nu)./Ee.*sum(uzs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz1,2); 207 | Iuz2 = q.*alpha.*(-1)*H.*(1+Nu)./Ee.*sum(uzs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz2,2); 208 | uz = (4.*Iuz2-Iuz1)./3; 209 | 210 | %%%%% u_r %%%%% 211 | urs = besselj(1,xip_r.*repmat(rho,1,nz)).*... 212 | (... 213 | (Aa+Cc.*(1+xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(Lami-z/H,1,nz))+... 214 | (Bb-Dd.*(1-xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(z/H-Lami1,1,nz))... 215 | ); 216 | 217 | % Improve the convergence for points residing close to the surface 218 | Iur1 = q.*alpha.*H.*(1+Nu)./Ee.*sum(urs.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir1,2); 219 | Iur2 = q.*alpha.*H.*(1+Nu)./Ee.*sum(urs.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir2,2); 220 | ur = (4*Iur2-Iur1)/3; 221 | 222 | % ------------------------------------------------------------------------- 223 | % STRESSES 224 | % ------------------------------------------------------------------------- 225 | %%%%% Sigma_z %%%%% 226 | sigma_zs = -xip_z.*besselj(0,xip_z.*repmat(rho,1,nz)).*... 227 | (... 228 | (Aa-Cc.*(1-2*repmat(Nu,1,nz)-xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(Lami-z/H,1,nz))+... 229 | (Bb+Dd.*(1-2*repmat(Nu,1,nz)+xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(z/H-Lami1,1,nz))... 230 | ); 231 | 232 | % Improve the convergence for points residing close to the surface 233 | Isz1 = q.*alpha.*sum(sigma_zs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz1,2); 234 | Isz2 = q.*alpha.*sum(sigma_zs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz2,2); 235 | sigma_z = (4*Isz2-Isz1)/3; 236 | 237 | %%%%% sigma_r %%%%% 238 | sigma_rs = (xip_r.*besselj(0,xip_r.*repmat(rho,1,nz))... 239 | -((besselj(1,xip_r.*repmat(rho,1,nz)))./repmat(rho,1,nz))).*... 240 | (... 241 | (Aa+Cc.*(1+xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(Lami-z/H,1,nz))+... 242 | (Bb-Dd.*(1-xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(z/H-Lami1,1,nz))... 243 | )+ 2*repmat(Nu,1,nz).*xip_r.*besselj(0,xip_r.*repmat(rho,1,nz)).*... 244 | (Cc.*exp(-xip_r.*repmat(Lami-z/H,1,nz))-Dd.*exp(-xip_r.*repmat(z/H-Lami1,1,nz))); 245 | 246 | % Improve the convergence for points residing close to the surface 247 | Isr1 = q.*alpha.*sum(sigma_rs.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir1,2); 248 | Isr2 = q.*alpha.*sum(sigma_rs.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir2,2); 249 | sigma_r = (4*Isr2-Isr1)/3; 250 | 251 | %%%%% sigma_theta %%%%% 252 | sigma_thetas = (besselj(1,xip_r.*repmat(rho,1,nz))./repmat(rho,1,nz)).*... 253 | (... 254 | (Aa+Cc.*(1+xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(Lami-z/H,1,nz))+... 255 | (Bb-Dd.*(1-xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(z/H-Lami1,1,nz))... 256 | )+ 2*repmat(Nu,1,nz).*xip_r.*besselj(0,xip_r.*repmat(rho,1,nz)).*... 257 | (Cc.*exp(-xip_r.*repmat(Lami-z/H,1,nz))-Dd.*exp(-xip_r.*repmat(z/H-Lami1,1,nz))); 258 | 259 | % Improve the convergence for points residing close to the surface 260 | Isr1 = q.*alpha.*sum(sigma_thetas.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir1,2); 261 | Isr2 = q.*alpha.*sum(sigma_thetas.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir2,2); 262 | sigma_theta = (4*Isr2-Isr1)/3; 263 | 264 | %%%%% tau_rz %%%%% 265 | tau_rzs = xip_z.*besselj(1,xip_z.*repmat(rho,1,nz)).*... 266 | (... 267 | (Aa+Cc.*(2*repmat(Nu,1,nz)+xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(Lami-z/H,1,nz))-... 268 | (Bb-Dd.*(2*repmat(Nu,1,nz)-xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(z/H-Lami1,1,nz))... 269 | ); 270 | 271 | % Improve the convergence for points residing close to the surface 272 | Itr1 = q.*alpha.*sum(tau_rzs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz1,2); 273 | Itr2 = q.*alpha.*sum(tau_rzs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz2,2); 274 | tau_rz = (4*Itr2-Itr1)/3; 275 | 276 | % ------------------------------------------------------------------------- 277 | % Transformation between (r,theta) and (x,y) coordinates 278 | % ------------------------------------------------------------------------- 279 | % Below a transformation of each response (evaluated above from 280 | % the (r,theta) coordinates to the (x,y) coordinates are made. After the 281 | % transformation, the responses are added together. 282 | 283 | % p (load point) 284 | % (z is downwards) 285 | % z-> x ^ (deformation vector ur; pointing towards the load) 286 | % | / 287 | % y v / 288 | % o (deformation point) 289 | % 290 | % NB: the r-axis (goes in the direction 291 | 292 | % Transformation matrix (each point-to-load radius results in 3 deformations) 293 | T = sparse(3*length(r),3*length(r),(3*3-4)*length(r)); 294 | 295 | % Organize content of the T matrix 296 | COS = (Xd(:,1)-Xl(:,1))./r; 297 | SIN = (Xd(:,2)-Xl(:,2))./r; % Minus on y-coordinate because z-axis points 298 | % downward 299 | 300 | % Replace content in COS and SIN with, respectively, 1 and 0 if r = 0 301 | COS(find(r==0)) = 1; 302 | SIN(find(r==0)) = 0; 303 | 304 | % Transformation matrix is denoted S (and we use its transpose = inverse 305 | % in the transformation). This is given as: 306 | % S = T =[ cos(theta) sin(theta) 0 = [ Xd(:,1)-Xl(:,1) , Xd(:,2)-Xl(:,2) , 0 307 | % -sin(theta) cos(theta) 0 -(Xd(:,2)-Xl(:,2)) , Xd(:,1)-Xl(:,1) , 0 308 | % 0 0 1]; 0 , 0 , r]*1/r; 309 | 310 | % Address the content into the matrix 311 | T(1:3*3*length(r)+3:end) = COS; 312 | T(2:3*3*length(r)+3:end) = -SIN; 313 | T(3*length(r)+1:3*3*length(r)+3:end) = SIN; 314 | T(3*length(r)+2:3*3*length(r)+3:end) = COS; 315 | T(2*3*length(r)+3:3*3*length(r)+3:end) = 1; 316 | 317 | % Organize displacement vector 318 | u1 = zeros(length(r)*3,1); 319 | u1(1:3:end) = ur; 320 | %u1(2:3:end) = 0; % Displacements transverse to the radius (u_theta = 0) 321 | u1(3:3:end) = uz; 322 | 323 | % Organize stress matrix 324 | sig1 = sparse(length(r)*3,length(r)*3,(3*3-4)*length(r)); 325 | sig1(1:3*3*length(r)+3:end) = sigma_r; 326 | sig1(3*length(r)+2:3*3*length(r)+3:end) = sigma_theta; 327 | sig1(2*3*length(r)+3:3*3*length(r)+3:end) = sigma_z; 328 | sig1(3:3*3*length(r)+3:end) = tau_rz; 329 | sig1(2*3*length(r)+1:3*3*length(r)+3:end) = tau_rz; 330 | 331 | % Transform deformations in to (x,y,z)-coordinates 332 | u1 = T'*u1; 333 | u = u1; 334 | 335 | % Transform stresses into (x,y,z)-coordinates 336 | sig1 = T'*sig1*T; 337 | sigm = sig1; 338 | 339 | % Transform 3x3 matrices into 6x1 vectors 340 | dos = zeros(6*xd*xl,1); 341 | dos(1:6:end-5) = 1:9*xd*xl+3:9*xd*xl*length(r); 342 | dos(2:6:end-4) = dos(1:6:end-5) + 3*xd*xl+1; 343 | dos(3:6:end-3) = dos(1:6:end-5) + 2*3*xd*xl+2; 344 | dos(4:6:end-2) = dos(1:6:end-5) + 1; 345 | dos(5:6:end-1) = dos(2:6:end-4) + 1; 346 | dos(6:6:end) = dos(1:6:end-5) + 2; 347 | 348 | sigv = sigm(dos); 349 | 350 | % Organize matrix Txyz for adding displacements together 351 | unos = zeros(3*xd*xl,1); % Number of ones in Txyz 352 | unos(1:xl) = 1:9*xd:9*xl*xd; 353 | unos(xl+1:2*xl) = unos(1:xl)+3*xd+1; 354 | unos(2*xl+1:3*xl) = unos(1:xl)+2*3*xd+2; 355 | 356 | for i=1:xd-1 357 | unos(3*xl+1+3*xl*(i-1):3*xl+3*xl*i) = unos(1:3*xl)+i*(3*xd*3*xl+3); 358 | end 359 | 360 | % Matrix adding contributions together from different loads 361 | Txyz = spalloc(3*xd,3*length(r),length(unos)); 362 | Txyz(unos) = 1; 363 | 364 | % Organize matrix Mxyz for adding displacements together 365 | tres = zeros(6*xd*xl,1); % Number of ones in Txyz 366 | tres(1:xl) = 1:9*4*xd:9*4*xl*xd; 367 | tres(xl+1:2*xl) = tres(1:xl)+6*xd+1; 368 | tres(2*xl+1:3*xl) = tres(1:xl)+2*6*xd+2; 369 | tres(3*xl+1:4*xl) = tres(1:xl)+3*6*xd+3; 370 | tres(4*xl+1:5*xl) = tres(1:xl)+4*6*xd+4; 371 | tres(5*xl+1:6*xl) = tres(1:xl)+5*6*xd+5; 372 | 373 | for i=1:xd-1 374 | tres(6*xl+1+6*xl*(i-1):6*xl+6*xl*i)=tres(1:6*xl)+i*(6*xd*6*xl+6); 375 | end 376 | 377 | % Matrix adding contributions together from different loads 378 | Mxyz = spalloc(6*xd,6*length(r),length(tres)); 379 | Mxyz(tres) = 1; 380 | 381 | % Final response vector 382 | 383 | % Displacements 384 | u = Txyz*u; 385 | alva.ux = u(1:3:end-2); 386 | alva.uy = u(2:3:end-1); 387 | alva.uz = u(3:3:end); 388 | 389 | % Stresses 390 | sig = -Mxyz*full(sigv); % minus inserted to fullfil inwards positive 391 | % sign convention 392 | alva.sigx = sig(1:6:end-5); 393 | alva.sigy = sig(2:6:end-4); 394 | alva.sigz = sig(3:6:end-3); 395 | alva.sigxy = sig(4:6:end-2); 396 | alva.sigyz = sig(5:6:end-1); 397 | alva.sigxz = sig(6:6:end); 398 | 399 | % Strains 400 | Eel = Ee(1:xl:end); % Reduce vector to evaluation points only 401 | Nul = Nu(1:xl:end); % Reduce vector to evaluation points only 402 | 403 | alva.epsx = 1./Eel.*(alva.sigx-Nul.*(alva.sigy+alva.sigz)); 404 | alva.epsy = 1./Eel.*(alva.sigy-Nul.*(alva.sigz+alva.sigx)); 405 | alva.epsz = 1./Eel.*(alva.sigz-Nul.*(alva.sigx+alva.sigy)); 406 | alva.epsxy = (1+Nul)./Eel.*alva.sigxy; 407 | alva.epsyz = (1+Nul)./Eel.*alva.sigyz; 408 | alva.epsxz = (1+Nul)./Eel.*alva.sigxz; 409 | -------------------------------------------------------------------------------- /basic/LET_response.m: -------------------------------------------------------------------------------- 1 | function alva = LET_response(alva) 2 | %-------------------------------------------------------------------------- 3 | % DESCRIPTION: 4 | % This function evaluates the response of a layered elastic half-space 5 | % model utilizing Linear Elastic Theory (LET) [1],[2],[3]. 6 | 7 | % INPUT PARAMETERS: 8 | Xd = alva.Xd; % Output coordinates (x,y,z) 9 | Xl = alva.Xl; % Load posistion coordinates (x,y) 10 | a = alva.a; % Load radii 11 | q = alva.q; % Load pressure 12 | E = alva.E; % Layer Young's moduli 13 | nu = alva.nu; % Layer Poisson's ratios 14 | zi = alva.zi; % Layer interface depths (i.e. depth of layer n-1 out 15 | % of n layers (layer n depth goes to infinity) 16 | XipWip = alva.XipWip; % Integration points and weights used in integration 17 | ABCD = alva.ABCD; % Coefficients of integration 18 | 19 | % ------------------------------------------------------------------------- 20 | % References 21 | % ------------------------------------------------------------------------- 22 | %[1] Burmister, D. M. (1945). The general theory of stresses and 23 | % displacements in layered systems. i. Journal of applied physics, 16(2) 24 | % , 89–94. 25 | %[2] Huang, Y.H., 2003. Pavement Analysis Design, 2nd Edition, 26 | % Prentice-Hall, New Jersey. 27 | %[3] Ioannides, A. M., & Khazanovich, L. (1998). General formulation for 28 | % multilayered pavement systems. Journal of transportation engineering, 29 | % 124(1), 82–90. 30 | % ------------------------------------------------------------------------- 31 | % If we only have one layer, we generate two layers 32 | 33 | % If zi has more entries than length(E)-1, these are removed. In principle 34 | % the last entry in zi is infinite. However, the infinite value is not 35 | % included in this code, as we do not operate with infinite number. We 36 | % handle this in an optional way. 37 | if length(zi) <= length(E) 38 | zi(length(E):end) = []; 39 | end 40 | 41 | % The code is organized such that we need a minimum of 2 layers! Check if 42 | % zi has at least one value 43 | if isempty(zi) 44 | disp('the code is arranged such that we need minimum two layers!!') 45 | end 46 | 47 | % Define depth of layer n-1 out of n layers (layer n depth goes to infinity) 48 | H = zi(end); 49 | 50 | % Check if the length of E and nu are equal 51 | if length(E) ~= length(nu) 52 | disp('length(E) ~= length(nu) !!!') 53 | end 54 | 55 | % Number of loads (xl) and deformation points (xd) 56 | xl = size(Xl,1); % Number of load points 57 | xd = size(Xd,1); % Number of deformation points 58 | 59 | % Make sure that the length of q and a are correct. These should be equal 60 | % to the number of loads. 61 | if length(q) < xl || length(a) < xl 62 | disp('Number of q and/or a values is lower than the number of load coordinates (= number of loads), so all loads are given the same q- and a-values') 63 | q = q(1)*ones(xl,1); 64 | a = a(1)*ones(xl,1); 65 | end 66 | 67 | % Make sure that q and a are vectors "standing up" 68 | if size(q,1) < size(q,2) 69 | q = q'; 70 | end 71 | 72 | if size(a,1) < size(a,2) 73 | a = a'; 74 | end 75 | 76 | % Make sure that zi is a 'horizontal' vector 77 | if size(zi,1) > size(zi,2) 78 | zi = zi'; 79 | end 80 | 81 | % Increase Xl, q, alpha, Xd and z in order to estimate the radius from each 82 | % of the loads to all of the points. The number of radii are: xl*xd 83 | Xl = repmat(Xl,[xd,1]); % Extends with the number of evaluation 84 | % points 85 | q = repmat(q,[xd,1]); % -||- 86 | alpha = repmat(a/H,[xd,1]); % -||- 87 | Xd = repmat(Xd,[xl,1]); % -||- <-- is reorganized below to 88 | % correspond to the right Xl content/sequence 89 | 90 | % Reorganize Xd so the first xl rows correspond to the same deformation 91 | % point, and following xl rows correspond to the next deformation point 92 | % etc... see description of the vector r nine lines below to understand the 93 | % organization 94 | 95 | % Built dx vector used to reorganize/sort Xd in the right order 96 | dx = repmat(1:xd,xl,1); 97 | dx = dx(:)' + repmat(0:xd:xd*(xl-1),1,xd); 98 | Xd = Xd(dx,:); 99 | z = Xd(:,3); 100 | 101 | % Evaluate the radii between evaluation point and load 102 | % r = [ evaluation point 1 and load 1 103 | % evaluation point 1 and load 2 104 | % evaluation point 1 and load 3 105 | % . 106 | % evaluation point 1 and load N 107 | % evaluation point 2 and load 1 108 | % evaluation point 2 and load 2 109 | % . 110 | % . 111 | % last evaluation point and load N]; 112 | 113 | r = sqrt((Xd(:,1)-Xl(:,1)).^2 + (Xd(:,2)-Xl(:,2)).^2); 114 | 115 | % Introduce the parameter rho (notice: since r is a vector, rho is too) 116 | rho = r/H; 117 | rho(rho==0) = 1e-20; % insert a small value to avoid singularity in 118 | % calculation of stresses 119 | 120 | % Integration points and weights (takes out the length(rho) rows in XipWip 121 | % related to one load for one position) 122 | lrho = length(rho); % Number of load-to-displacement-points 123 | xip_z = XipWip(0*lrho+1:1*lrho,:); % takes out the first length(rho) rows 124 | wip_z = XipWip(1*lrho+1:2*lrho,:); % takes out next 125 | xip_r = XipWip(2*lrho+1:3*lrho,:); % etc... 126 | wip_r = XipWip(3*lrho+1:4*lrho,:); % etc... 127 | 128 | % Number of columns in reorganized integration points and weights (= number 129 | % of integration points per integral) 130 | nz = size(xip_z,2); 131 | 132 | % The depth z defines which E, nu, Ai, Bi, Ci and Di values should be used 133 | % in the different required evaluations of the response. A 134 | % horizontal vector called layer_no gives the information of which 135 | % values should be used. The length(layer_no) corresponds to the number of 136 | % radii, r, we have (i.e. the length of rho = r/H). 137 | 138 | % Layer number where the point we use is given* 139 | layer_no = sum(repmat(z,1,length(zi)) > repmat(zi,length(rho),1),2)'+1; 140 | 141 | % *Note: if (Xd,z) is larger than (zi,1) the function gives 1+1 142 | % = layer no. 2, if (Xd,z) is larger than (zi,2) the function gives 1+1+1 143 | % = layer no. 3 etc. 144 | 145 | Lami = zeros(length(rho),1); 146 | Lami1 = Lami; 147 | for i = 1:length(rho) % length(layer_no) = n3 148 | 149 | % Evaluate the lam_i value (if we are in the bottom layer, Lam_i=infinite) 150 | if layer_no(i) > length(zi) 151 | Lami(i) = zi(end)/H*1e20; % In principle Lami is multiplied by 152 | % A = 0 and C = 0 at the bottom layer, 153 | % and this value and will not have any 154 | % contribution 155 | else 156 | Lami(i) = zi(layer_no(i))/H; 157 | end 158 | 159 | % Evaluate the lam_{i-1} value (NB! lam_{0} = 0) 160 | if layer_no(i) == 1 % (= lam_{i-1} = lam{0}) 161 | Lami1(i) = 0; 162 | else 163 | Lami1(i) = zi(layer_no(i)-1)/H; 164 | end 165 | end 166 | 167 | % Evaluating response 168 | 169 | % Summation form 170 | % length(rho) = number of point to load radii, nz = number of integration 171 | % points in every point to load integral 172 | Aa = zeros(length(rho),nz); Bb = Aa; Cc = Aa; Dd = Aa; 173 | 174 | for j = 1:length(rho) % number of point to load radii 175 | % n in function below = number of layers = length(E) 176 | % m in function below = number of integration points = xip_z(j,:) 177 | 178 | ABCDz = arb_func_interp(length(E),xip_z(j,:),ABCD); 179 | 180 | % Select the relevant A, B, C and D values for the response points 181 | % considered 182 | Aa(j,:) = ABCDz((layer_no(j)-1)*4+1,:); 183 | Bb(j,:) = ABCDz((layer_no(j)-1)*4+2,:); 184 | Cc(j,:) = ABCDz((layer_no(j)-1)*4+3,:); 185 | Dd(j,:) = ABCDz((layer_no(j)-1)*4+4,:); 186 | end 187 | 188 | % Define E and Nu values for the layer considered for the evaluation of response 189 | Nu = nu(layer_no)'; 190 | Ee = E(layer_no)'; 191 | 192 | % Define exponential functions for one-step Richardson extrapolation 193 | x1 = 2^(-20); 194 | Iz1 = exp(-x1*xip_z.^2); 195 | Iz2 = exp(-(x1/2)*xip_z.^2); 196 | Ir1 = exp(-x1*xip_r.^2); 197 | Ir2 = exp(-(x1/2)*xip_r.^2); 198 | 199 | % ------------------------------------------------------------------------- 200 | % DISPLACEMENTS 201 | % ------------------------------------------------------------------------- 202 | % first part incl. J0: solved outside sum for all integration points 203 | % and then included inside sumation below 204 | 205 | %%%%% u_z %%%%% 206 | uzs = besselj(0,xip_z.*repmat(rho,1,nz)).*... 207 | (... 208 | (Aa-Cc.*(2-4*repmat(Nu,1,nz)-xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(Lami-z/H,1,nz))-... 209 | (Bb+Dd.*(2-4*repmat(Nu,1,nz)+xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(z/H-Lami1,1,nz))... 210 | ); 211 | 212 | % Improve the convergence for points residing close to the surface 213 | Iuz1 = q.*alpha.*(-1)*H.*(1+Nu)./Ee.*sum(uzs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz1,2); 214 | Iuz2 = q.*alpha.*(-1)*H.*(1+Nu)./Ee.*sum(uzs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz2,2); 215 | uz = (4.*Iuz2-Iuz1)./3; 216 | 217 | %%%%% u_r %%%%% 218 | urs = besselj(1,xip_r.*repmat(rho,1,nz)).*... 219 | (... 220 | (Aa+Cc.*(1+xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(Lami-z/H,1,nz))+... 221 | (Bb-Dd.*(1-xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(z/H-Lami1,1,nz))... 222 | ); 223 | 224 | % Improve the convergence for points residing close to the surface 225 | Iur1 = q.*alpha.*H.*(1+Nu)./Ee.*sum(urs.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir1,2); 226 | Iur2 = q.*alpha.*H.*(1+Nu)./Ee.*sum(urs.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir2,2); 227 | ur = (4*Iur2-Iur1)/3; 228 | 229 | % ------------------------------------------------------------------------- 230 | % STRESSES 231 | % ------------------------------------------------------------------------- 232 | %%%%% Sigma_z %%%%% 233 | sigma_zs = -xip_z.*besselj(0,xip_z.*repmat(rho,1,nz)).*... 234 | (... 235 | (Aa-Cc.*(1-2*repmat(Nu,1,nz)-xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(Lami-z/H,1,nz))+... 236 | (Bb+Dd.*(1-2*repmat(Nu,1,nz)+xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(z/H-Lami1,1,nz))... 237 | ); 238 | 239 | % Improve the convergence for points residing close to the surface 240 | Isz1 = q.*alpha.*sum(sigma_zs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz1,2); 241 | Isz2 = q.*alpha.*sum(sigma_zs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz2,2); 242 | sigma_z = (4*Isz2-Isz1)/3; 243 | 244 | %%%%% sigma_r %%%%% 245 | sigma_rs = (xip_r.*besselj(0,xip_r.*repmat(rho,1,nz))... 246 | -((besselj(1,xip_r.*repmat(rho,1,nz)))./repmat(rho,1,nz))).*... 247 | (... 248 | (Aa+Cc.*(1+xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(Lami-z/H,1,nz))+... 249 | (Bb-Dd.*(1-xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(z/H-Lami1,1,nz))... 250 | )+ 2*repmat(Nu,1,nz).*xip_r.*besselj(0,xip_r.*repmat(rho,1,nz)).*... 251 | (Cc.*exp(-xip_r.*repmat(Lami-z/H,1,nz))-Dd.*exp(-xip_r.*repmat(z/H-Lami1,1,nz))); 252 | 253 | % Improve the convergence for points residing close to the surface 254 | Isr1 = q.*alpha.*sum(sigma_rs.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir1,2); 255 | Isr2 = q.*alpha.*sum(sigma_rs.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir2,2); 256 | sigma_r = (4*Isr2-Isr1)/3; 257 | 258 | %%%%% sigma_theta %%%%% 259 | sigma_thetas = (besselj(1,xip_r.*repmat(rho,1,nz))./repmat(rho,1,nz)).*... 260 | (... 261 | (Aa+Cc.*(1+xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(Lami-z/H,1,nz))+... 262 | (Bb-Dd.*(1-xip_r.*repmat(z/H,1,nz))).*exp(-xip_r.*repmat(z/H-Lami1,1,nz))... 263 | )+ 2*repmat(Nu,1,nz).*xip_r.*besselj(0,xip_r.*repmat(rho,1,nz)).*... 264 | (Cc.*exp(-xip_r.*repmat(Lami-z/H,1,nz))-Dd.*exp(-xip_r.*repmat(z/H-Lami1,1,nz))); 265 | 266 | % Improve the convergence for points residing close to the surface 267 | Isr1 = q.*alpha.*sum(sigma_thetas.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir1,2); 268 | Isr2 = q.*alpha.*sum(sigma_thetas.*besselj(1,xip_r.*repmat(alpha,1,nz))./xip_r.*wip_r.*Ir2,2); 269 | sigma_theta = (4*Isr2-Isr1)/3; 270 | 271 | %%%%% tau_rz %%%%% 272 | tau_rzs = xip_z.*besselj(1,xip_z.*repmat(rho,1,nz)).*... 273 | (... 274 | (Aa+Cc.*(2*repmat(Nu,1,nz)+xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(Lami-z/H,1,nz))-... 275 | (Bb-Dd.*(2*repmat(Nu,1,nz)-xip_z.*repmat(z/H,1,nz))).*exp(-xip_z.*repmat(z/H-Lami1,1,nz))... 276 | ); 277 | 278 | % Improve the convergence for points residing close to the surface 279 | Itr1 = q.*alpha.*sum(tau_rzs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz1,2); 280 | Itr2 = q.*alpha.*sum(tau_rzs.*besselj(1,xip_z.*repmat(alpha,1,nz))./xip_z.*wip_z.*Iz2,2); 281 | tau_rz = (4*Itr2-Itr1)/3; 282 | 283 | % ------------------------------------------------------------------------- 284 | % Transformation between (r,theta) and (x,y) coordinates 285 | % ------------------------------------------------------------------------- 286 | % Below a transformation of each response (evaluated above from 287 | % the (r,theta) coordinates to the (x,y) coordinates are made. After the 288 | % transformation, the responses are added together. 289 | 290 | % p (load point) 291 | % (z is downwards) 292 | % z-> x ^ (deformation vector ur; pointing towards the load) 293 | % | / 294 | % y v / 295 | % o (deformation point) 296 | % 297 | % NB: the r-axis (goes in the direction 298 | 299 | % Transformation matrix (each point-to-load radius results in 3 deformations) 300 | T = sparse(3*length(r),3*length(r),(3*3-4)*length(r)); 301 | 302 | % Organize content of the T matrix 303 | COS = (Xd(:,1)-Xl(:,1))./r; 304 | SIN = (Xd(:,2)-Xl(:,2))./r; % Minus on y-coordinate because z-axis points 305 | % downward 306 | 307 | % Replace content in COS and SIN with, respectively, 1 and 0 if r = 0 308 | COS(find(r==0)) = 1; 309 | SIN(find(r==0)) = 0; 310 | 311 | % Transformation matrix is denoted S (and we use its transpose = inverse 312 | % in the transformation). This is given as: 313 | % S = T =[ cos(theta) sin(theta) 0 = [ Xd(:,1)-Xl(:,1) , Xd(:,2)-Xl(:,2) , 0 314 | % -sin(theta) cos(theta) 0 -(Xd(:,2)-Xl(:,2)) , Xd(:,1)-Xl(:,1) , 0 315 | % 0 0 1]; 0 , 0 , r]*1/r; 316 | 317 | % Address the content into the matrix 318 | T(1:3*3*length(r)+3:end) = COS; 319 | T(2:3*3*length(r)+3:end) = -SIN; 320 | T(3*length(r)+1:3*3*length(r)+3:end) = SIN; 321 | T(3*length(r)+2:3*3*length(r)+3:end) = COS; 322 | T(2*3*length(r)+3:3*3*length(r)+3:end) = 1; 323 | 324 | % Organize displacement vector 325 | u1 = zeros(length(r)*3,1); 326 | u1(1:3:end) = ur; 327 | %u1(2:3:end) = 0; % Displacements transverse to the radius (u_theta = 0) 328 | u1(3:3:end) = uz; 329 | 330 | % Organize stress matrix 331 | sig1 = sparse(length(r)*3,length(r)*3,(3*3-4)*length(r)); 332 | sig1(1:3*3*length(r)+3:end) = sigma_r; 333 | sig1(3*length(r)+2:3*3*length(r)+3:end) = sigma_theta; 334 | sig1(2*3*length(r)+3:3*3*length(r)+3:end) = sigma_z; 335 | sig1(3:3*3*length(r)+3:end) = tau_rz; 336 | sig1(2*3*length(r)+1:3*3*length(r)+3:end) = tau_rz; 337 | 338 | % Transform deformations in to (x,y,z)-coordinates 339 | u1 = T'*u1; 340 | u = u1; 341 | 342 | % Transform stresses into (x,y,z)-coordinates 343 | sig1 = T'*sig1*T; 344 | sigm = sig1; 345 | 346 | % Transform 3x3 matrices into 6x1 vectors 347 | dos = zeros(6*xd*xl,1); 348 | dos(1:6:end-5) = 1:9*xd*xl+3:9*xd*xl*length(r); 349 | dos(2:6:end-4) = dos(1:6:end-5) + 3*xd*xl+1; 350 | dos(3:6:end-3) = dos(1:6:end-5) + 2*3*xd*xl+2; 351 | dos(4:6:end-2) = dos(1:6:end-5) + 1; 352 | dos(5:6:end-1) = dos(2:6:end-4) + 1; 353 | dos(6:6:end) = dos(1:6:end-5) + 2; 354 | 355 | sigv = sigm(dos); 356 | 357 | % Organize matrix Txyz for adding displacements together 358 | unos = zeros(3*xd*xl,1); % Number of ones in Txyz 359 | unos(1:xl) = 1:9*xd:9*xl*xd; 360 | unos(xl+1:2*xl) = unos(1:xl)+3*xd+1; 361 | unos(2*xl+1:3*xl) = unos(1:xl)+2*3*xd+2; 362 | 363 | for i=1:xd-1 364 | unos(3*xl+1+3*xl*(i-1):3*xl+3*xl*i) = unos(1:3*xl)+i*(3*xd*3*xl+3); 365 | end 366 | 367 | % Matrix adding contributions together from different loads 368 | Txyz = spalloc(3*xd,3*length(r),length(unos)); 369 | Txyz(unos) = 1; 370 | 371 | % Organize matrix Mxyz for adding displacements together 372 | tres = zeros(6*xd*xl,1); % Number of ones in Txyz 373 | tres(1:xl) = 1:9*4*xd:9*4*xl*xd; 374 | tres(xl+1:2*xl) = tres(1:xl)+6*xd+1; 375 | tres(2*xl+1:3*xl) = tres(1:xl)+2*6*xd+2; 376 | tres(3*xl+1:4*xl) = tres(1:xl)+3*6*xd+3; 377 | tres(4*xl+1:5*xl) = tres(1:xl)+4*6*xd+4; 378 | tres(5*xl+1:6*xl) = tres(1:xl)+5*6*xd+5; 379 | 380 | for i=1:xd-1 381 | tres(6*xl+1+6*xl*(i-1):6*xl+6*xl*i)=tres(1:6*xl)+i*(6*xd*6*xl+6); 382 | end 383 | 384 | % Matrix adding contributions together from different loads 385 | Mxyz = spalloc(6*xd,6*length(r),length(tres)); 386 | Mxyz(tres) = 1; 387 | 388 | % Final response vector 389 | 390 | % Displacements 391 | u = Txyz*u; 392 | alva.ux = u(1:3:end-2); 393 | alva.uy = u(2:3:end-1); 394 | alva.uz = u(3:3:end); 395 | 396 | % Stresses 397 | sig = -Mxyz*full(sigv); % minus inserted to fullfil inwards positive 398 | % sign convention 399 | alva.sigx = sig(1:6:end-5); 400 | alva.sigy = sig(2:6:end-4); 401 | alva.sigz = sig(3:6:end-3); 402 | alva.sigxy = sig(4:6:end-2); 403 | alva.sigyz = sig(5:6:end-1); 404 | alva.sigxz = sig(6:6:end); 405 | 406 | % Strains 407 | Eel = Ee(1:xl:end); % Reduce vector to evaluation points only 408 | Nul = Nu(1:xl:end); % Reduce vector to evaluation points only 409 | 410 | alva.epsx = 1./Eel.*(alva.sigx-Nul.*(alva.sigy+alva.sigz)); 411 | alva.epsy = 1./Eel.*(alva.sigy-Nul.*(alva.sigz+alva.sigx)); 412 | alva.epsz = 1./Eel.*(alva.sigz-Nul.*(alva.sigx+alva.sigy)); 413 | alva.epsxy = (1+Nul)./Eel.*alva.sigxy; 414 | alva.epsyz = (1+Nul)./Eel.*alva.sigyz; 415 | alva.epsxz = (1+Nul)./Eel.*alva.sigxz; 416 | --------------------------------------------------------------------------------