2 Trabalho de Mecnica dos Slidos (EME301)

- Prof. Leonardo Kyo Kabayama

Exerccio 1)
- GIVEN/INPUT:
Tanque sendo enchido lentamente com gua, cuja densidade r de 10
kg/m, at uma altura d de 0 at 3m;
Largura de seo l de 1m de comprimento; O ngulo de inclinao B entre
a base e a superfcie lateral inclinada;

- ANALISYS:
Para placa na vertical: (r*((h-2.1)^2)*l)/2
Para placa com inclinao: (r*(h^2)*l)/2sen B

- OUTLINE OF PROGRAM:
public float calculaPressao(){ // se a altura for menor que 2.1, usa apenas
a frmula I: (densidade*(altura^2)*largura)/2sen B
// caso a altura seja maior, ento calcula a
diferena entre o resultado para a altura total
// e o resultado para a (altura-2.1), usando a
frmula I. depois somado a isso, o resultado da
// frmula II: (densidade*((altura2.1)^2)*largura)/2
float resultado;
if (d < 2.1){
resultado = (float)((densidade*(Math.pow(d, 2))*largura)/
(2*(Math.sin(Math.PI/3))));
} else{

resultado = (float)((densidade*((Math.pow(d,2))-(Math.pow((d-2.1),
2)))*largura)/(2*(Math.sin(Math.PI/3)))+
(densidade*(Math.pow((d-2.1),2))*largura)/2);
}
return resultado;
}
- OUTPUT:
As presses resultantes em ABC de 0 a 3 com incremento de 0,25 so:
0.0 N
36.084393 N
144.33757 N
324.75952 N
577.3503 N
902.1098 N
1299.0381 N
1768.1353 N
2309.4011 N
2921.0955 N
3596.0632 N
4333.531 N
5133.4985 N

Exerccio 2)
-GIVEN/INPUT:
A altura h da rea, a largura da sua base a e o expoente m da funo;

-ANALISYS:
Calcula a rea usado a integrao por somatrio de retngulos.

Usa frmula dada no enunciado para o clculo do centroide:

Cx = ((n+1)/(n+2))*rea
Cy = ((n+1)/(4n+2))*rea
Usa a seguinte frmula para descobrir o k:
1/k = x/y
no programa fica : k = (Math.pow(x,2))/hMax
e o k usado dividindo, pois o obtido pela conta igual a 1/k
-OUTLINE OF PROGRAM:
public float calculaK(){
return (float)Math.pow(x,m)/hMax;
}
public float integra (){
int i;
areaAnt = 0;
a1 = 0;
for (i=0; i<999999; i++){
a2 = (x/1000000)*i; // divide a largura em 1000000 diferenciais
b = a2-a1; //Base
aMed = (a2+a1)/2; // DeltaA/2
a1 = a2; // a1 atualiza para a2, para o prximo calculo
h = (float) Math.pow(aMed, m)/k; // calcula a altura, que o valor da
//funo y =kx^m
area = b*h;
areaAnt = areaAnt+area;
}
return areaAnt;
}
// componente y do centroide
public float centroideY(){
return ((m+1)*hMax)/((4*m)+2); // da frmula (n+1 / 4n+2)*h

}
public float centroideX(){
float distX = ((m+1)*x)/(m+2); // da frmula (n+1 / n+2)*a
return distX;
}
-OUTPUT:
a)
A rea de superfcie de: 2133.0828mm -> a rea estimada foi
2133,3333. erro de 0,012%
O centride est na posio (60.0 ; 24.0).
b)
A rea de superfcie de: 13332.877mm -> a rea estimada foi
13333,3333. erro de 0,003%
O centride est na posio (60.0 ; 150.0).
c)
A rea de superfcie de: 1066.6665mm -> a rea estimada foi
1066,6666. erro de 0,000009%
O centride est na posio (68.57143 ; 21.818182).
d)
A rea de superfcie de: 6666.587mm -> a rea estimada foi 1066,6666.
erro de 0,015%
O centride est na posio (68.57143 ; 136.36363).

Exerccio 3)
-GIVEN/INPUT:
Tamanho da base b para cada figura; Altura h para cada figura;
Distncia do centride at o eixo x dx de cada figura;
Distncia do centride at o eixo y dy de cada figura;
reas a de cada figura; rea total at;

-ANALISYS:
Momento de Incia:
Para retngulos cujo centride se localiza na origem dos eixos:
Ix = b*h^3/12
Iy = h*b^3/12

Caso o centride esteja deslocado:

Ix = (b*h^3/12) + a*dx^2
Iy = (h*b^3/12) + a*dy^2
Raio de girao:
kx^2 = Ix/a
ky^2 = Iy/a

-OUTLINE OF PROGRAM:
public void calcularMomentoInercia() {
double mx = 0, my = 0;
int i = 0;
do {
if (considerada[i] == true) { //nesse caso o momento somado ao
momento total (positivo)
//cada if analisa a distncia da figura a cada eixo para determinar
se deve somar ou subtrair distncias aos centrides
if (dx[i] != 0) {
if (dx[i] > 0) {
if (dy[i] > 0) {
mx += ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] + (ay[i] / 2)), 2);
my += ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] + (ax[i] / 2)), 2);
} else if (dy[i] < 0) {

mx += ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *

pow((dx[i] + (ay[i] / 2)), 2);
my += ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] - (ax[i] / 2)), 2);
} else {
mx += ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] + (ay[i] / 2)), 2);
my += ((ay[i] * pow(ax[i], 3)) / 12);
}
}
if (dx[i] < 0) {
if (dy[i] > 0) {
mx += ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] - (ay[i] / 2)), 2);
my += ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] + (ax[i] / 2)), 2);
} else if (dy[i] < 0) {
mx += ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] - (ay[i] / 2)), 2);
my += ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] - (ax[i] / 2)), 2);
} else {
mx += ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] - (ay[i] / 2)), 2);
my += ((ay[i] * pow(ax[i], 3)) / 12);
}
}

} else {
if (dy[i] > 0) {
mx += ((ax[i] * pow(ay[i], 3)) / 12);

my += ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *

pow((dy[i] + (ax[i] / 2)), 2);
} else if (dy[i] < 0) {
mx += ((ax[i] * pow(ay[i], 3)) / 12);
my += ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] - (ax[i] / 2)), 2);
} else {
mx += ((ax[i] * pow(ay[i], 3)) / 12);
my += ((ay[i] * pow(ax[i], 3)) / 12);
}
}
} else {
if (dx[i] != 0) {
if (dx[i] > 0) {
if (dy[i] > 0) {
mx -= ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] + (ay[i] / 2)), 2);
my -= ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] + (ax[i] / 2)), 2);
} else if (dy[i] < 0) {
mx -= ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] + (ay[i] / 2)), 2);
my -= ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] - (ax[i] / 2)), 2);
} else {
mx -= ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] + (ay[i] / 2)), 2);
my -= ((ay[i] * pow(ax[i], 3)) / 12);
}
}
if (dx[i] < 0) {

if (dy[i] > 0) {
mx -= ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] - (ay[i] / 2)), 2);
my -= ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] + (ax[i] / 2)), 2);
} else if (dy[i] < 0) {
mx -= ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] - (ay[i] / 2)), 2);
my -= ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] - (ax[i] / 2)), 2);
} else {
mx -= ((ax[i] * pow(ay[i], 3)) / 12) + (ax[i] * ay[i]) *
pow((dx[i] - (ay[i] / 2)), 2);
my -= ((ay[i] * pow(ax[i], 3)) / 12);
}
}
} else {
if (dy[i] > 0) {
mx -= ((ax[i] * pow(ay[i], 3)) / 12);
my -= ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] + (ax[i] / 2)), 2);
} else if (dy[i] < 0) {
mx -= ((ax[i] * pow(ay[i], 3)) / 12);
my -= ((ay[i] * pow(ax[i], 3)) / 12) + (ay[i] * ax[i]) *
pow((dy[i] - (ax[i] / 2)), 2);
} else {
mx -= ((ax[i] * pow(ay[i], 3)) / 12);
my -= ((ay[i] * pow(ax[i], 3)) / 12);
}
}
}

i++;
} while (i < ax.length);
}
public void calcularRaioGiracao() {
double rx = 0, ry = 0;
int i = 0;
rx = sqrt(ix / a);
ry = sqrt(iy / a);
setKx(rx);
setKy(ry);
}
-OUTPUT:
a)
O momento de inrcia com relao ao eixo x 389952.0mm^4
O momento de inrcia com relao ao eixo y 64256.0mm^4
O raio de girao com relao ao eixo x 21.860520417894367mm
O raio de girao com relao ao eixo y 8.873843476150325mm
b)
O momento de inrcia com relao ao eixo x 46.0 inch^4
O momento de inrcia com relao ao eixo y 46.5 inch^4
O raio de girao com relao ao eixo x 1.5986105077709065 inch
O raio de girao com relao ao eixo y 1.6072751268321592 inch

Exercicio 4)
-GIVEN/INPUT: os centrides de cada figura, cX e cY, assim como a base e a
altura de cada figura.
-ANALISYS:
o centride deve ser dado j com o valor deslocado (se for o caso).

o programa pega o x e o y do centroide e multiplica pela rea da

figura, que por ser um retngulo,
h*b
e temos a somatria: (area+cY+cX)1 + (area+cY+cX)2 +
(area+cY+cX)3.
-OUTLINE OF PROGRAM:
public void calcularProdutoInercia() {
double cX1, cY1, base1, altura1, area1;
double cX2, cY2, base2, altura2, area2;
double cX1, cY3, base3, altura3, area3;
double aXY1, aXY2, aXY3;
double jxy;
// area de cada figura
area1 = base1*altura1;
area2 = base2*altura2;
area3 = base3*altura3;
// produto de inercia de cada figura dados os centrides cX e cY
(distncia at o eixo)
aXY1 = area1*cX1*cY1;
aXY2 = area2*cX2*cY2;
aXY3 = area3*cX3*cY3;
// produto de inercia total
jxy = aXY1+aXY2+aXY3;
}
- OUTPUT:
a) produto de inercia = 471040 mm^4
b) produto de inercia = -4,25320 in^4