Sei sulla pagina 1di 27

Triangular element

Dicembre 2020
Quadrilateral element

Le matrici di un elemento quadrangolare


vengono calcolate mediante
l’introduzione di due gradi di libertà
aggiuntivi in corrispondenza 7 5

dell’intersezione fra le diagonali di 8 6

elemento. 9

Si calcolano quindi le matrici relative a 4 10


elementi triangolari, le quali vengono 1
3
successivamente assemblate. 2
4
I due gradi di libertà aggiuntivi vengono
poi eliminati mediante condensazione
statica.

Dicembre 2020
Rectangular element

Dicembre 2020
4 node isoparametric element

Physical domain Parent domain

In un elemento rettangolare le funzioni di forma


risultano lineari lungo i lati; stessa cosa non può dirsi
per un elemento quadrangolare. La formulazione
isoparametrica risolve il problema poichè un
generico dominio fisico (physical domain) viene
mappato in un sistema di riferimento standard
(parent domain) mediante apposite funzioni forma.

Dicembre 2020
4 node isoparametric element

Compatibility
matrix

La derivate delle funzioni forma, espresse nel parent Considerando la relazione tra i due
system (𝜉, 𝜂), rispetto le coordinate fisiche 𝑥, 𝑦 , sistemi di riferimento:
richiedono le seguenti trasformazioni:

Matrice
Jacobiana

Dicembre 2020
4 node isoparametric element

Considerando ogni punto di Gauss ed il rispettivo peso:

Calcolo la matrice di compatibilità relative ad ogni Gauss point e ne sommo i contributi pesati:

External force vector:

Stato tensionale e deformativo:

Dicembre 2020
Isoparametric element: single element application

- Calcolo coordinate punti di Gauss [gauss_points];

- Calcolo della matrice di rigidezza [iso_stiffness];

- Risoluzione del sistema di equilibrio;

7
5
- Verifica dell’equilibrio tra forze esterne ed interne;
8
6

2 - Calcolo stato tensionale e deformativo [iso_stressdef].

Dicembre 2020
clc
clear all
%Input variables
ex=[0;2;2;0]; %x coordinates
ey=[0;0.5;1;1]; %y coordinates
E=30000000; %elastic modulus
ni=0.3; %poisson ratio
eq=[0;-20]; %load values
n=[3,4]; %extremes of loaded side
t=1; %thickness

%Calcolo delle coordinate dei punti di gauss


[x_gp,y_gp,x_sr,y_sr] = gauss_points(ex,ey);

%struttura indeformata + sistema di riferimento


eldraw2(ex',ey',[1,1,1]);
eldraw2(x_sr(:,[1,3]),y_sr(:,[1,3]),[2,2,1]);
eldraw2(x_sr(:,[2,4]),y_sr(:,[2,4]),[2,2,1]);
hold on
plot(x_sr,y_sr,'bo')
hold on
scatter(x_sr,y_sr,'filled')
plot(x_gp,y_gp,'r.')
text(x_gp(:,1),y_gp(:,1),'[1]');
text(x_gp(:,2),y_gp(:,2),'[2]');
text(x_gp(:,3),y_gp(:,3),'[3]');
text(x_gp(:,4),y_gp(:,4),'[4]');

%Calcolo della matrice di rigidezza


D=hooke(1,E,ni);
[K,f]=iso_stiffness(ex,ey,D,t,eq,n)
ep=[1,1,2];
Ke=plani4e(ex',ey',ep,D); %(verifica)

%Risoluzione del sistema di equilibrio


bc=[1,0;2,0;7,0;8,0];
[d,R]=solveq(K,f,bc);
F=f+R; %external forces

%calcolo dello stato tensionale e deformativo


[ eps,sigma,f_verify ] = iso_stressdef(ex,ey,d,D,t);

%verifica dell'equilibrio tra forze esterne e interne


gap=f_verify-F;

Published with MATLAB® R2017a

1
function [x_gp,y_gp,x_sr,y_sr] = gauss_points(ex,ey)
%Position of Gauss points in the physical element
gp=0.57735;
xsi=[-gp,gp,gp,-gp];
eta=[-gp,-gp,gp,gp];

%Relation between physical and parent domain

%calcolo delle coordinate dei punti di gauss


for i=1:4
N=zeros(4,4);
Nf(i,:)=N(i,:)+[1/4*(1-xsi(i))*(1-eta(i)),1/4*(1+xsi(i))*(1-
eta(i)),1/4*(1+xsi(i))*(1+eta(i)),1/4*(1-xsi(i))*(1+eta(i))];
x=zeros(4,1); y=zeros(4,1);
x_gp(i)=x(i)+Nf(i,:)*ex;
y_gp(i)=y(i)+Nf(i,:)*ey;
end

xsr=[0,1,0,-1];
ysr=[-1,0,1,0];

%calcolo delle coordinate del sistema di riferimento locale


for i=1:4
N=zeros(4,4);
Nsr(i,:)=N(i,:)+[1/4*(1-xsr(i))*(1-ysr(i)),1/4*(1+xsr(i))*(1-
ysr(i)),1/4*(1+xsr(i))*(1+ysr(i)),1/4*(1-xsr(i))*(1+ysr(i))];
x=zeros(4,1); y=zeros(4,1);
x_sr(i)=x(i)+Nsr(i,:)*ex;
y_sr(i)=y(i)+Nsr(i,:)*ey;
end
end

Published with MATLAB® R2017a

1
function [K,f] = iso_stiffness(ex,ey,D,t,eq,n)
%Give the stiffness matrix and the load vector
%eq=load value=[ex;ey] in the local system
%n=[initial node,final node] where initial/final node is 1,2,3 or 4.

if nargin==4 b=zeros(2,1); nodes=[0,0]; else b=eq; nodes=n; end


%gauss points
gp=0.577350269189626;
x_gp=[-gp;gp;gp;-gp];
y_gp=[-gp;-gp;gp;gp];
xsi=x_gp;
eta=y_gp;
%shape functions
N(:,1)=(1-xsi).*(1-eta)/4;
N(:,2)=(1+xsi).*(1-eta)/4;
N(:,3)=(1+xsi).*(1+eta)/4;
N(:,4)=(1-xsi).*(1+eta)/4;
%derivatives of shape functions wrt xi-eta
dN(1:4,1)=(eta-1)/4;
dN(1:4,2)=(-eta+1)/4;
dN(1:4,3)=(eta+1)/4;
dN(1:4,4)=(-eta-1)/4;

dN(5:8,1)=(xsi-1)/4;
dN(5:8,2)=(-xsi-1)/4;
dN(5:8,3)=(xsi+1)/4;
dN(5:8,4)=(-xsi+1)/4;
%Jacobian matrix
J=dN*[ex,ey];
K=zeros(8,8);
for i=1:4

indx=[i;i+4];

detJ=det(J(indx,:));
inv_J=inv(J(indx,:));

dN_xy=inv_J*dN(indx,:);
%compatibility matrix
B=[dN_xy(1,1),0,dN_xy(1,2),0,dN_xy(1,3),0,dN_xy(1,4),0;
0,dN_xy(2,1),0,dN_xy(2,2),0,dN_xy(2,3),0,dN_xy(2,4);
dN_xy(2,1),dN_xy(1,1),dN_xy(2,2),dN_xy(1,2),dN_xy(2,3),...
dN_xy(1,3),dN_xy(2,4),dN_xy(1,4)];

K=K+B'*D*B*detJ*t;
end
%calcolo del vettore dei carichi nodali solo se l'elemento presenta
un lato caricato
if nodes(:,1)==1 && nodes(:,2)==2
N1=1; N2=1; N3=0; N4=0; L=sqrt((ex(1)-ex(2))^2+(ey(1)-ey(2))^2);
elseif nodes(:,1)==2 && nodes(:,2)==3
N1=0; N2=1; N3=1; N4=0; L=sqrt((ex(2)-ex(3))^2+(ey(2)-ey(3))^2);

1
elseif nodes(:,1)==3 && nodes(:,2)==4
N1=0; N2=0; N3=1; N4=1; L=sqrt((ex(3)-ex(4))^2+(ey(3)-ey(4))^2);
elseif nodes(:,1)==0 && nodes(:,2)==0
N1=0; N2=0; N3=0; N4=0; L=0;
else nodes(:,1)==4 && nodes(:,2)==1
N1=1; N2=0; N3=0; N4=1;L =sqrt((ex(1)-ex(4))^2+(ey(1)-ey(4))^2);
end

N_f=[N1,0,N2,0,N3,0,N4,0;
0,N1,0,N2,0,N3,0,N4];
f=N_f'*b*t*L/2;
end

Published with MATLAB® R2017a

2
function [ eps,sigma,f_verify ] = iso_stressdef( ex,ey,d,D,t)
%UNTITLED Summary of this function goes here
% Detailed explanation goes here
%gauss points
gp=0.577350269189626;
x_gp=[-gp;gp;gp;-gp];
y_gp=[-gp;-gp;gp;gp];
xsi=x_gp;
eta=y_gp
%shape functions
N(:,1)=(1-xsi).*(1-eta)/4;
N(:,2)=(1+xsi).*(1-eta)/4;
N(:,3)=(1+xsi).*(1+eta)/4;
N(:,4)=(1-xsi).*(1+eta)/4;

%derivatives of shape functions wrt xi-eta


dN(1:4,1)=(eta-1)/4;
dN(1:4,2)=(-eta+1)/4;
dN(1:4,3)=(eta+1)/4;
dN(1:4,4)=(-eta-1)/4;

dN(5:8,1)=(xsi-1)/4;
dN(5:8,2)=(-xsi-1)/4;
dN(5:8,3)=(xsi+1)/4;
dN(5:8,4)=(-xsi+1)/4;

%jacobian matrix
J=dN*[ex,ey];
eps=zeros(3,4);
sigma=zeros(3,4);
f_verify=zeros(8,1);
for i=1:4
indx=[i;i+4];

detJ=det(J(indx,:));
inv_J=inv(J(indx,:));

dN_xy=inv_J*dN(indx,:);

B=[dN_xy(1,1),0,dN_xy(1,2),0,dN_xy(1,3),0,dN_xy(1,4),0;
0,dN_xy(2,1),0,dN_xy(2,2),0,dN_xy(2,3),0,dN_xy(2,4);
dN_xy(2,1),dN_xy(1,1),dN_xy(2,2),dN_xy(1,2),dN_xy(2,3),...
dN_xy(1,3),dN_xy(2,4),dN_xy(1,4)];

eps(:,i)=eps(:,i)+B*d;
sigma(:,i)=D*eps(:,i);
f_verify=f_verify+detJ*B'*sigma(:,i)*t;
end
end

Published with MATLAB® R2017a

1
Isoparametric element: panel in elasticity

Dicembre 2020
Isoparametric element: panel in elasticity

𝝈𝒙

𝝈𝒚

τ𝒙𝒚

Dicembre 2020
Isoparametric element: panel in elasticity

- Modellazione su GMSH ed importazione [import_msh];

- Calcolo coordinate punti di Gauss e nodi [mesh_coordinate];

- Calcolo della matrice topologica;

- Calcolo delle matrici di rigidezza ed assemblaggio;

- Risoluzione del sistema di equilibrio;

- Verifica dell’equilibrio tra forze esterne ed interne;

- Calcolo stato tensionale e deformativo.

Dicembre 2020
panel constrained in the bottom side and loaded in the top one

25 19 13 7 1 ‘elementi_carico’

26 20 14 8 2

27 21 15 9 3
‘elementi_sigma’ ‘no_carico’

28 22 16 10 4

29 23 17 11 5

30 24 18 12 6 ‘elementi_bc’

Dicembre 2020
Importazione file da GMSH

GMSH: Structured (Transfinite) Rectangular Mesh (5/6 Pt) – YouTube

1) Geometry> Elementary entities> Add> Point (nodi esterni);


2) Geometry> Elementary entities> Add> Line;
3) Geometry> Elementary entities> Add> Plane surface;
4) Geometry> Physical groups> Add> Curve;
5) Mesh> Define> Transfinite> Surface;
6) Mesh> Define> Transfinite> Curve (in base alla mesh);
7) Mesh> Define> Ricombine;
8) Mesh> 2D;
9) Export>estensione: gmsh .msh , version 4 ASCII, save all elements.

10) Edit with Notepad: eliminare parti relative a Physical names e Entities.

Dicembre 2020
clear all
clc
%importo da gmsh
[dnodes,deles,txtlines] = import_msh('articolo.msh');
[ nodes,ex,ey ] = MESH_COORDINATE( dnodes, deles );
siz=size(deles);

%struttura indeformata
for i=1:siz(1,1)
eldraw2(ex(:,i)',ey(:,i)',[1,2,0]);
end
%coordinate dei punti di gauss
for i=1:siz(1,1)
[x_gp(:,i),y_gp(:,i),x_sr(:,i),y_sr(:,i)] =
gauss_points(ex(:,i),ey(:,i));
figure (1)
eldraw2(x_sr([1,3],i)',y_sr([1,3],i)',[2,2,0]);
eldraw2(x_sr([2,4],i)',y_sr([2,4],i)',[2,2,0]);
hold on
plot(x_gp(:,i),y_gp(:,i),'r.')
end

%input variables
E=1670000;
ni=0.15;
D=hooke(1,E,ni);
ep=[1,5,2];
thick=5;

%Identifico elementi caricati e non


no_carico=zeros(siz(1,1),1); %elementi che non presentano carico
distribuito
n_row=6; %questo valore dipendono dalla specifica mesh utilizzata
n_column=5; %questo valore dipendono dalla specifica mesh utilizzata

no_carico(1,:)=no_carico(1,:)+1; %assegno il primo elemento


elementi_carico=zeros(n_column,1); %elementi che presentano carico
distribuito

for i=2:siz(1,1);
no_carico(i,:)=no_carico(i-1,:)+1; %assegno i valori successivi
end

%calcolo considerando un salto tra gli stessi pari al numero di righe


della mesh
for i=1:n_column

elementi_carico(i,:)=elementi_carico(i,:)+no_carico(1+(i-1)*(n_row),:); end
%cancello gli elementi effettivamente caricati
for i=1:n_column
no_carico(1+(i-1)*(n_row-1),:)=[];
end

1
nc=size(no_carico);
elementi_nocarico=nc(1,1); %n di elementi non caricati

%Calcolo delle matrici di rigidezza


%calcolo la matrice di rigidezza per gli elementi che non presentano
carico distribuito
for i=1:elementi_nocarico
t(i)=no_carico(i,:);
n=[0,0];
eq=[0;0];
[Ke(:,:,t(i)),fe(:,:,t(i))] =
iso_stiffness(ex(:,t(i)),ey(:,t(i)),D,thick,eq,n);
end
eq=[0;-30]; %N/cm^2
n=[3,4];
%calcolo la matrice di rigidezza per gli elementi che presentano
carico distribuito
for i=1:n_column
s(i)=elementi_carico(i,:);
[Ke(:,:,s(i)),fe(:,:,s(i))] =
iso_stiffness(ex(:,s(i)),ey(:,s(i)),D,thick,eq,n);
end

%Calcolo della matrice topologica


Edof=zeros(siz(1,1),5); %inizializzo la matrice Edof(contiene i nodi)

for i=1:siz(1,1)
Edof(i,1)=dnodes(i,1); %prima colonna=nome elemento
Edof(i,2:5)=nodes(:,1,i); %2-5 colonna=4 nodi elemento
end

nele=size(deles);
elements=nele(1,1); %n elementi

for i=1:elements
gdl(i,:)=[Edof(i,2)*2-1,Edof(i,2)*2,Edof(i,3)*2-1,Edof(i,3)*2,...
Edof(i,4)*2-1,Edof(i,4)*2,Edof(i,5)*2-1,Edof(i,5)*2];
Edof_gdl(i,1)=Edof(i,1);
Edof_gdl(i,2:9)=gdl(i,:); %calcolo la matrice Edof(che stavolta
continene gli effettivi gdl)
end
nnodes=size(dnodes); %n nodi

%Calcolo della matrice di rigidezza assemblata


K_tot=zeros(nnodes(1,1)*2,nnodes(1,1)*2);
f_tot=zeros(nnodes(1,1)*2,1);

for i=1:elements

[K_tot,f_tot]=assem(Edof_gdl(i,:),K_tot,Ke(:,:,i),f_tot,fe(:,:,i));
end
% f_tot(5,1)=-40000;
elementi_bc=zeros(n_column,1);

2
for i=1:n_column
elementi_bc(i,:)=elementi_bc(i,:)+i*n_row;%elementi che presentano
nodi vincolati
end
bc=zeros(n_column*2+2,2);%boundary conditions
bc(1:4,1)=Edof_gdl(elementi_bc(1),2:5);
for i=2:n_column
bc((i-1)*2+3:(i-1)*2+4,1)=Edof_gdl(elementi_bc(i,:),2:3);
end

%Risoluzione del sistema di equilibrio


[displ,reaction]=solveq(K_tot,f_tot,bc);

for i=1:elements
[ed(:,i)]=extract(Edof_gdl(i,:),displ);
end

%Verifica di equilibrio
F_interne=zeros(nnodes(1,1)*2,1);
for i=1:elements
[ eps(:,:,i),sigma(:,:,i),f_verify(:,i) ] =
iso_stressdef(ex(:,i),ey(:,i),ed(:,i),D,thick);
a(i,:)=Edof_gdl(i,2:end);
F_interne(a(i,:))=F_interne(a(i,:))+f_verify(:,i);
end
F_elements=reaction+f_tot;
gap=F_interne-F_elements;

%Stato tensionale su un piano intermedio all'altezza del pannello


sigma_orizz=zeros(3,2*n_column);
for i=1:n_column
elementi_sigma=elementi_bc(end:-1:1)-ones(n_column,1)*fix(n_row/2);
sigma_orizz(:,(i-1)*2+1)=sigma(:,1,elementi_sigma(i,:));
sigma_orizz(:,(i-1)*2+2)=sigma(:,2,elementi_sigma(i,:));
end

%plottaggio stato tensionale


figure (2)
plot(sigma_orizz(1,:));
figure (3)
plot(sigma_orizz(2,:));
for i=1:n_column
tau(:,i)=sigma_orizz(3,2*i-1);
end
figure (4)
plot(tau);

Published with MATLAB® R2017a

3
function [dnodes,deles,txtlines] = import_msh(fileext)

fid = fopen(fileext,'r');
tline = fgetl(fid);
tlines = cell(0,1);
while ischar(tline)
tlines{end+1,1} = tline;
tline = fgetl(fid);
end
fclose(fid);
A = tlines(5,1); A = string(A); A = str2double(A);
B = tlines(6 : A+5,1);
B = string(B);
for i = 1 : A
C(i,:) = str2num(B{i});
end
dnodes = C;

D = tlines(9+A:end-1,1); D = string(D);
kk = size(D,1);
A1 = zeros(1,9);
for i = 1 : kk;
A = str2num(D{i});
if size(A) == size(A1);
el5(i,:) = A;
end
end; clear A1

ind1 = el5(:,1) >0;


el5 = el5(ind1,:);
deles = el5;
txtlines = string(tlines);

end

Published with MATLAB® R2017a

1
function [ nodes,ex,ey ] = MESH_COORDINATE( dnodes, deles )
%UNTITLED Summary of this function goes here
% Detailed explanation goes here

deles(:,1:5)=[];
%riordino i nodi in senso antiorario da quello in basso a sx
delementi(:,1)=deles(:,3);
delementi(:,2)=deles(:,4);
delementi(:,3)=deles(:,1);
delementi(:,4)=deles(:,2);
siz=size(delementi);
nodes=zeros(4,4,siz(:,1));
ex=zeros(4,siz(:,1));
ey=zeros(4,siz(:,1));
%costruisco la matrice con le coordinate dei nodi, organizzate poi nei
%vettori delle coordinate nodali dei songoli elementi
for i=1:siz(:,1)
elem(:,i)=delementi(i,:);
nodes(:,:,i)=dnodes(elem(:,i),:);
ex(:,i)=nodes(:,2,i);
ey(:,i)=nodes(:,3,i);
end

end

Published with MATLAB® R2017a

1
Panel in elasticity with a central hole

Dicembre 2020
Panel in elasticity with a central hole

- Importazione di file .csv (‘nodi_foro’ e


‘elementiforo’);

- Calcolo coordinate punti di Gauss e vettore


delle coordinate;

- Calcolo della matrice topologica;

- Calcolo delle matrici di rigidezza ed


assemblaggio;

- Risoluzione del sistema di equilibrio;

- Struttura deformata (x5000).

Dicembre 2020
Impostazione file .csv

11 12 13 14 15 16 17 18 19 20
142 143 144 145 146 147 148 149 150
31 32 33 34 35 36 37 38 39 40
… 182 183 184 185

41 42 43 44 …
.. . .. .
. ‘Nodi_foro’ .. . ‘Elementiforo’ .. 21 22 23 24 25 26 27 28 29 30
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10

Dicembre 2020
clear all
clc

%%%%%%%%%%%%%% INPUT DATA %%%%%%%%%%%%%%%%


E=1670000; %modulo di young
ni=0.15; %coefficiente di Poisson
sigma_0=200; %N/cm2
El=hooke(1,E,ni); %matrice elastica
ep=[1,10,2];
thick=10; %thickness
n_row=18; %numero righe mesh
n_column=9; %numero colonne
s_imposto=0.002; %spostamento imposto

%%%%%%%%%%%%%%%%%%%%% LETTURA FILE .csv%%%%%%%%%%%%%%%%%%%%%


dnodes=importdata('Nodi_foro.csv'); %coordinate x-y nodi
deles=importdata('Elementi_foro.csv'); %nodi di elemento
connett=deles;
nele=size(deles);
elements=nele(1,1); %n di elementi
nnodes=size(dnodes);
dof=nnodes(1,1)*2; %g.d.l.

%%%%%%% STRUTTURA INDEFORMATA %%%%%%%%


siz=size(deles);
for i=1:siz(:,1)
ex(:,i)=dnodes(deles(i,2:5)',2); %vettori coordinate nodali
ey(:,i)=dnodes(deles(i,2:5)',3);
eldraw2(ex(:,i)',ey(:,i)',[2 2 0]);
end

%%%%%%% COORDINATE PUNTI DI GAUSS %%%%%%%%


for i=1:elements
[x_gp(:,1),y_gp(:,i),x_sr(:,i),y_sr(:,i)] =
gauss_points(ex(:,i),ey(:,i));
% hold on
% plot(x_gp(:,i),y_gp(:,i),'r.')
end

%%%%%%%%%%%% COSTRUZIONE MATRICI DI RIGIDEZZA %%%%%%%%%%%%%


eq=[0;0]; %elementi scarichi
n=[0,0];
for i=1:elements
[Ke(:,:,i),fe(:,:,i)] = plani4e(ex(:,i)',ey(:,i)',ep,El,eq);
end

%%%%%%%%%%%% COSTRUZIONE MATRICE TOPOLOGICA %%%%%%%%%%%%%


Edof=deles;
for i=1:elements
gdl(i,:)=[Edof(i,2)*2-1,Edof(i,2)*2,Edof(i,3)*2-1,Edof(i,3)*2,...
Edof(i,4)*2-1,Edof(i,4)*2,Edof(i,5)*2-1,Edof(i,5)*2];
Edof_gdl(i,1)=Edof(i,1);

1
Edof_gdl(i,2:9)=gdl(i,:);
end

%%%%%%%%%%%% ASSEMBLAGGIO %%%%%%%%%%%%%


K_tot=zeros(nnodes(1,1)*2,nnodes(1,1)*2);
f_tot=zeros(nnodes(1,1)*2,1);

for i=1:elements

[K_tot,f_tot]=assem(Edof_gdl(i,:),K_tot,Ke(:,:,i),f_tot,fe(:,:,i));
end

%%%%%%%% BOUNDARY CONDITIONS %%%%%%%%%


bc=zeros(2*(n_column+1),2);
bc(1:4*(n_column+1),1)=Edof_gdl(1:4*(n_column+1),1); %vincolo alla
base
displ_vert=-0.0019840135;
for n=1:(n_column+1)
bc(2*(n_column+1)+(2*n-1),2)=s_imposto; %spostamento orizzontale
imposto in testa
bc(2*(n_column+1)+(2*n),2)=displ_vert; %spostamento verticalr
imposto in testa
end

%%%%%% RISOLUZIONE SISTEMA DI EQUILIBRIO %%%%%%%


[displ,reaction]=solveq(K_tot,f_tot,bc);

for i=1:elements
[ed(:,i)]=extract(Edof_gdl(i,:),displ);
end

%%%%%% STRUTTURA DEFORMATA %%%%%


hold on
for i=1:elements
eldisp2(ex(:,i)',ey(:,i)',ed(:,i)',[1 4 0],5000);
end

Published with MATLAB® R2020a

Potrebbero piacerti anche