static void propGeometricasPerfilU(Perfil perfil)
{
double t = perfil.PegarEspessura();
double elemento1 = perfil.PegarElemento1();
double elemento2 = perfil.PegarElemento2();
double elemento3 = perfil.PegarElemento3();
ycg = elemento3 * 0.5;
area = t * (PerfilU.b1m + PerfilU.b2m + PerfilU.b3m + b4m + b5m);
xg = (b2m * t * (b2m + 2 * b1m)) / area; // Com relação a linha média da alma
//Mesa
double momentobx2 = (b2m * Math.Pow(t, 3)) / 12;
double momentoby2 = (t * Math.Pow(b2m, 3)) / 12;;
double areaB2 = b2m * t;
double yB2 = ycg - t / 2; //Distancia do eixo até a linha media da mesa
double xB2 = (0.5 * b2m) - xg;
//Alma
double momentobx3 = (t * Math.Pow(b3m, 3)) / 12;
double momentoby3 = (b3m * Math.Pow(t, 3)) / 12;
double areaB3 = b3m * t;
double xb3 = xg;
//Enrijecedores
double momentobx1 = (t * Math.Pow(b1m, 3)) / 12;
double momentoby1 = (b1m * Math.Pow(t, 3)) / 12;
double areaB1 = b1m * t;
double yB1 = ycg - (0.5 * t + b1m * 0.5);
double xb1 = elemento2 - xg - t;
//Momento em X
iPerfilX = 2 * (momentobx2 + areaB2 * Math.Pow(yB2, 2)) + 2 * (momentobx1 + areaB1 * Math.Pow(yB1, 2))
+ momentobx3;
rx = Math.Sqrt(iPerfilX / area);
moduloWx = iPerfilX / ycg;
// Calculo do xo, cw, J
// Momento em Y
iPerfilY = (momentoby3 + areaB3 * Math.Pow(xb3, 2)) +
2 * (momentoby2 + areaB2 * Math.Pow(xB2, 2)) +
2 * (momentoby1 + areaB1 * Math.Pow(xb1, 2));
ry = Math.Sqrt(iPerfilY / area);
moduloWy = iPerfilY / xg;
double am = b3m;
double bm, cm = b1m;
double bethaL, bethaF, bethaW;
if (b1m == 0)
{
bethaL = 0;
bm = b2m;
xo = (Math.Pow(bm, 2) / (am + 2 * bm)) + (3 * Math.Pow(bm, 2)) / (6 * bm + am); //Wei-Wu pg. 385
jx = (Math.Pow(t, 3) * (am + 2 * bm)) / 3;
cw = ((t * Math.Pow(am, 2) * Math.Pow(bm, 3)) / 12) * ((3 * bm + 2 * am) / (6 * bm + am));
}
else
{
bm = b2m;
// Wei Wu pg. 385
xo = xg + bm * ((6 * Math.Pow(am, 2) * cm + 3 * bm * Math.Pow(am, 2) - 8 * Math.Pow(cm, 3)) /
(Math.Pow(am, 3) + 6 * bm * Math.Pow(am, 2) + 6 * cm * Math.Pow(am, 2)
- 12 * am * Math.Pow(cm, 2) + 8 * Math.Pow(cm, 3)));
jx = Math.Pow(t, 3) * (am + 2 * bm + 2 * cm) / 3;
double Ix = t / 12 * (Math.Pow(am, 3) + 6 * bm * Math.Pow(am, 2) + 6 * cm * Math.Pow(am, 2)
- 12 * am * Math.Pow(cm, 2) + 8 * Math.Pow(cm, 3));
double m = bm * t / (12 * Ix) * (6 * cm * Math.Pow(am, 2) + 3 * bm * Math.Pow(am, 2) - 8 * Math.Pow(cm, 3));
cw = Math.Pow(t, 2) / area * (xg * area * Math.Pow(am, 2) / t * (Math.Pow(bm, 2) / 3 + Math.Pow(m, 2) - m * bm) +
area / (3 * t) * (Math.Pow(m, 2) * Math.Pow(am, 3) + Math.Pow(bm, 2) * Math.Pow(cm, 2) * (2 * cm + 3 * am)) -
Ix * Math.Pow(m, 2) / t * (2 * am + 4 * cm) +
m * Math.Pow(cm, 2) / 3 * (8 * Math.Pow(bm, 2) * cm + 2 * m * (2 * cm * (cm - am) + bm * (2 * cm - 3 * am))) +
Math.Pow(bm, 2) * Math.Pow(am, 2) / 6 * ((3 * cm + bm) * (4 * cm + am) - 6 * Math.Pow(cm, 2)) -
Math.Pow(m, 2) * Math.Pow(am, 4) / 4);
bethaL = 2 * cm * t * Math.Pow(bm - xg, 3) + 2 / 3 * t * (bm - xg) * ((Math.Pow(am / 2, 3) - Math.Pow(am / 2 - cm, 3)));
}
bethaF = (t / 2) * (Math.Pow((bm - xg), 4) - Math.Pow(xg, 4)) + (t * Math.Pow(am, 2) / 4) * (Math.Pow((bm - xg), 2) - Math.Pow(xg, 2));
bethaW = -(t * xg * Math.Pow(am, 3) / 12 + t * Math.Pow(xg, 3) * am);
jy = 1 / (2 * iPerfilY) * (bethaW + bethaL + bethaF) + xo;
ro = Math.Sqrt(Math.Pow(rx, 2) + Math.Pow(ry, 2) + Math.Pow(xo, 2));
}
public static List <double> // (area efetiva (0), modulo W x efetivo (1), modulo W efetivo Y (2))
propEfetivasPerfilU(Perfil perfil, List <double> listaEfetivos, string solicitacao)
{
double t = perfil.PegarEspessura();
double raio = perfil.PegarRaio();
double elemento1 = perfil.PegarElemento1();
double elemento2 = perfil.PegarElemento2();
double elemento3 = perfil.PegarElemento3();
double elemento5 = perfil.PegarElemento5();
double yCGefetivo, deslYcg, xCGefetivo, deslXcg;
double Iy = iPerfilY; //Inercia do Perfil em Y
double b1ef = listaEfetivos.ElementAt(1); double b2ef = listaEfetivos.ElementAt(2); double b3ef = listaEfetivos.ElementAt(3);
double b4ef = listaEfetivos.ElementAt(4); double b5ef = listaEfetivos.ElementAt(5); double ds = listaEfetivos.ElementAt(8);
double b2ef2 = listaEfetivos.ElementAt(8); double b3ef2 = listaEfetivos.ElementAt(9);
// A retirar de cada elemento
double retB1 = b1 - b1ef;
double retB2 = b2 - b2ef;
double retB3 = b3 - b3ef - b3ef2;
double retB4 = b4 - b4ef;
double retB5 = b5 - b5ef;
yCGefetivo = listaEfetivos.ElementAt(6);
deslYcg = Math.Abs(ycg - yCGefetivo);
xCGefetivo = listaEfetivos.ElementAt(7);
deslXcg = xg - xCGefetivo;
// Aera a retirar por elemento
double areaRet1 = retB1 * t;
double areaRet2 = retB2 * t;
double areaRet3 = retB3 * t;
double areaRet4 = retB4 * t;
double areaRet5 = retB5 * t;
double areaRetds; double retDs;
if (b1 != 0)
{
retDs = (b1 - ds);
areaRetds = t * retDs;
}
else
{
retDs = 0; areaRetds = 0;
}
double areaRet = (areaRet1 + areaRet2 + areaRet3 + areaRet4 + areaRet5 + areaRetds * 2);
double areaEfetiva = area - areaRet;
//==================================================================================
// Inercia a retirar por elemento, em X
// Enrijecedor - elemento 1
double yCGb1 = Funcoes.novoCGelementos(yCGefetivo, t, b1, retB1);
double inerciaRet1X = (t * Math.Pow(retB1, 3)) / 12 + areaRet1 * Math.Pow(yCGb1, 2);
// Mesa - elemento 2
double yCGb2 = (yCGefetivo - (t * 0.5));
double inerciaRet2X = (retB2 * Math.Pow(t, 3)) / 12 + areaRet2 * Math.Pow(yCGb2, 2);
// Alma - elemento 3
double yCGb3;
if (solicitacao == "COMPRESSAO")
{
yCGb3 = 0;
}
else // Flexao
{
yCGb3 = retB3 * 0.5;
}
double inerciaRet3X = (t * Math.Pow(retB3, 3)) / 12 + areaRet3 * Math.Pow(yCGb3, 2);
// Mesa - elemento 4
double yCGb4 = (yCGefetivo - (t * 0.5));
double inerciaRet4X = (retB4 * Math.Pow(t, 3)) / 12 + areaRet4 * Math.Pow(yCGb4, 2);
// Enrijecedor - elemento 5
double yCGb5 = Funcoes.novoCGelementos(yCGefetivo, t, b5, retB5);
double inerciaRet5X = (t * Math.Pow(retB5, 3)) / 12 + areaRet5 * Math.Pow(yCGb5, 2);
// Enrijecedor - conforme Item 9.2.3.1 (Largura efetiva de elementos comprimidos com enrijecedor)
double yCGds = Funcoes.novoCGelementos(yCGefetivo, t, b1, retDs);
double inerciaRetds = (t * Math.Pow(retDs, 3)) / 12 + areaRetds * Math.Pow(yCGds, 2);
double inerciaRetTotal;
if (solicitacao == "COMPRESSAO")
{ //retira-se duas vezes a não efetividade do enrijecedor, dado por ds
inerciaRetTotal = inerciaRet1X + inerciaRet2X + inerciaRet3X + inerciaRet4X + inerciaRet5X + inerciaRetds * 2;
}
else // Flexao em X
{//retira-se uma vez a não efetividade do enrijecedor, dado por ds
inerciaRetTotal = inerciaRet1X + inerciaRet2X + inerciaRet3X + inerciaRet4X + inerciaRet5X + inerciaRetds;
}
double inerciaEfetivaX = iPerfilX - inerciaRetTotal + areaEfetiva * Math.Pow(deslYcg, 2);
double moduloWXEfetivo = inerciaEfetivaX / yCGefetivo;
//==================================================================================
//Inercia a retirar por elemento, em Y
//Mesa - elemento 2
double retB2Y = b2 - (b2ef); //TODO ajustar o calculo da Wef, pois esta errado a definição do momento a retirar e Xcg
double xCGb2;
if (b1 == 0)
{
xCGb2 = b2 - retB2Y - xg;
}
else
{
xCGb2 = b2 * 0.5 - xg;
}
double areaRetB2y = retB2Y * t;
double inerciaRetB2Y = (t * Math.Pow(retB2Y, 3) / 12) + areaRetB2y * Math.Pow(xCGb2, 3);
//Alma - elemento 3
double retB3Y = b3 - (b3ef + b3ef2);
double xCGb3 = 0;
double areaRetB3y = retB3Y * t;
double inerciaRetB3y = (retB3Y * Math.Pow(t, 3) / 12) + areaRetB3y * Math.Pow(xCGb3, 2);
areaEfetiva = area - areaRetB2y - areaRetB3y;
inerciaRetTotal = inerciaRetB3y + inerciaRetB2Y;
double inerciaEfetivaY = iPerfilY - inerciaRetTotal + areaEfetiva * Math.Pow(deslXcg, 2);
double moduloWYEfetivo = inerciaEfetivaY / xCGefetivo;
List <double> retorno = new List <double>();
retorno.Add(areaEfetiva); retorno.Add(moduloWXEfetivo); retorno.Add(moduloWYEfetivo);
return(retorno);
}
MLEPerfilUFlexaoX(Perfil perfil, double tensao)
{
double t = perfil.PegarEspessura();
double raio = perfil.PegarRaio();
double elemento1 = perfil.PegarElemento1();
double elemento2 = perfil.PegarElemento2();
double elemento3 = perfil.PegarElemento3();
double elemento5 = perfil.PegarElemento5();
// Obtenção das larguras efetivas dos elementos de Perfil U
double ycgf = 0, contador = 3;
double ycgi = ycg, areaRetirar;
while (contador >= 2)
{
contador = 0;
//Obtenção das Larguras efetivas de cada elemento, nas configurações de Perfil U
// Enrijecedor
if (b1 == 0)
{
b1ef = 0;
}
else
{
b1ef = NBR.MLECompleta("AL", "FLEXAOX", tensao, b1, t, raio, b1, ycgi).ElementAt(0);
}
if (b1 == b1ef)
{
ycgf = ycgi;
}
else
{
areaRetirar = t * ((b1 - b1ef));
double areaEfetiva = area - t * ((b1 - b1ef));
ycgf = ycgi + ((areaRetirar / areaEfetiva) * (ycg - t * 0.5)); contador += 1;
}
// Mesa, totalmente comprimida
if (b1 == 0)
{ // Caso não tenha enrijecedor
b2ef = NBR.MLECompleta("AL", "COMPRESSAO", tensao, b2, t, raio, b2, ycgf);
areaRetirar = t * (b2 - b2ef.ElementAt(0));
areaEfetiva -= areaRetirar;
}
else
{ // Caso tenha enrijecedor
b2ef = NBR.elementoEnrijecido(b2, elemento1, b1ef, tensao, t);
areaRetirar = t * (b2 - b2ef.ElementAt(0) + b1 - b2ef.ElementAt(1));
areaEfetiva -= areaRetirar;
}
if (areaRetirar == 0)
{
}
else
{
ycgf += ((areaRetirar / areaEfetiva) * (ycg - t * 0.5)); contador += 1;
}
//Alma, parcialmente comprimida
b3ef = NBR.MLECompleta("AA", "FLEXAOX", tensao, b3, t, raio, b3, ycgf).ElementAt(0);
b3ef2 = NBR.MLECompleta("AA", "FLEXAOX", tensao, b3, t, raio, b3, ycgf).ElementAt(1);
if (b3 == b3ef + b3ef2)
{
}
else
{
areaRetirar = t * (b3 - b3ef - b3ef2);
areaEfetiva -= areaRetirar;
ycgf += Math.Round(((areaRetirar / areaEfetiva) * (ycg - t * 0.5)), 3); contador += 3;
}
if (contador >= 3) //Caso enrijecedor, mesa e alma não sejam totalmente efetivos;
{
double b3efi = b3ef; double b3ef2i = b3ef2;
b3ef = NBR.MLECompleta("AA", "FLEXAOX", tensao, b3, t, raio, b3, ycgf).ElementAt(0);
b3ef2 = NBR.MLECompleta("AA", "FLEXAOX", tensao, b3, t, raio, b3, ycgf).ElementAt(1);
areaRetirar = t * (b3 - b3ef - b3ef2);
areaEfetiva -= areaRetirar;
ycgf += Math.Round(((areaRetirar / areaEfetiva) * (ycg - t * 0.5)), 3);
double relacao = (b3efi + b3ef2i) / (b3ef + b3ef2); // Verifica se pode se desprezar a proxima iteração.
if (relacao < 0.95)
{
ycgi = ycgf; continue;
}
else
{
break;
}
}
ycgi = ycgf;
}
List <double> lstEfetivos = new List <double>();
// (t, b1ef, b2ef, b3ef, b4ef, b5ef, b3ef2)
lstEfetivos.Add(t); //0
lstEfetivos.Add(b1ef); //1, comprimid0
lstEfetivos.Add(b2ef.ElementAt(0)); //2, comprimida
lstEfetivos.Add(b3ef); //3. parcialmente comprimido
lstEfetivos.Add(b4); //4, tracionado
lstEfetivos.Add(b5); //5, tracionado
lstEfetivos.Add(ycgf); //6
lstEfetivos.Add(xg); //7
lstEfetivos.Add(b2ef.ElementAt(1)); //8, ds
lstEfetivos.Add(b3ef2); //9
return(lstEfetivos);
}
MLEPerfilUFlexaoY(Perfil perfil, double tensao)
{
double t = perfil.PegarEspessura();
double raio = perfil.PegarRaio();
double elemento1 = perfil.PegarElemento1();
double elemento2 = perfil.PegarElemento2();
double elemento4 = perfil.PegarElemento4();
double elemento3 = perfil.PegarElemento3();
double elemento5 = perfil.PegarElemento5();
double xgi, xgf = 0;
double tensaoAt1 = 0, tensaoAt2 = tensao;
xgi = xg;
// Primeira Situaçao - Alma comprimida
//Alma totalmente comprimida = elemento AA
while (tensaoAt1 != tensaoAt2) // TODO corrigir loop infinito
{
tensaoAt1 = tensaoAt2;
b3ef = NBR.MLECompleta("AA", "COMPRESSAO", tensaoAt1, b3, t, raio, b3, xg).ElementAt(0);
if (b3ef != b3)
{
double areaRetirar = (b3 - b3ef) * t;
xgf = xgi + areaRetirar / area * (xg - 0.5 * t);
}
else
{
xgf = xgi;
}
tensaoAt2 = Math.Round(tensao * xgf / (b2 - xgf), 2);
xgi = xgf;
if (xgf > elemento2)
{
xgf = elemento2; b3ef = 0; break;
}
}
//Verificação da Mesa, elemento parcialmente comprimido - AA
double xgMesa;
if (xgf > 0.5 * elemento2)
{
xgMesa = xgf;
}
else
{
xgMesa = elemento2 - xgf;
}
b2ef = NBR.MLECompleta("AA", "FLEXAOY", tensaoAt2, b2, t, raio, 0, xgMesa);
List <double> lstEfetivos = new List <double>();
// (t, b1ef, b2ef, b3ef, b4ef, b5ef, b3ef2)
lstEfetivos.Add(t); //0
lstEfetivos.Add(b1); //1
lstEfetivos.Add(b2ef.ElementAt(0)); //2
lstEfetivos.Add(b3ef); //3
lstEfetivos.Add(b2ef.ElementAt(0)); //4, b4ef
lstEfetivos.Add(b5); //5
lstEfetivos.Add(ycg); //6
lstEfetivos.Add(xgf); //7
lstEfetivos.Add(b2ef.ElementAt(1)); //8, ds
lstEfetivos.Add(b3ef2); //9
lstEfetivos.Add(b2ef.ElementAt(1)); //10, bef2
return(lstEfetivos);
}
MLEPerfilUCompressao(Perfil perfil, double tensao)
{
double t = perfil.PegarEspessura();
double raio = perfil.PegarRaio();
double elemento1 = perfil.PegarElemento1();
double elemento2 = perfil.PegarElemento2();
double elemento3 = perfil.PegarElemento3();
double elemento5 = perfil.PegarElemento5();
string solicitacao = "COMPRESSAO";
//Obtenção das Larguras efetivas de cada elemento, nas configurações de Perfil U
// Elementos totalmente comprimidos
if (b1 <= 0)
{
b1ef = 0;
}
else
{
b1ef = NBR.MLECompleta("AL", solicitacao, tensao, b1, t, raio, 0, ycg).ElementAt(0);
}
if (b1 <= 0)
{
b2ef = NBR.MLECompleta("AL", solicitacao, tensao, b2, t, raio, 0, ycg);
}
else
{
b2ef = NBR.elementoEnrijecido(b2, elemento1, b1ef, tensao, t);
}
b3ef = NBR.MLECompleta("AA", solicitacao, tensao, b3, t, raio, 0, ycg).ElementAt(0);
b3ef2 = NBR.MLECompleta("AA", solicitacao, tensao, b3, t, raio, 0, ycg).ElementAt(1);
if (b5 <= 0)
{
b5ef = 0;
}
else
{
b5ef = NBR.MLECompleta("AL", solicitacao, tensao, b5, t, raio, 0, ycg).ElementAt(0);
}
if (b5 <= 0)
{
b4ef = NBR.MLECompleta("AL", solicitacao, tensao, b4, t, raio, 0, ycg);
}
else
{
b4ef = NBR.elementoEnrijecido(b4, elemento5, b5ef, tensao, t);
}
List <double> listaEfetivos = new List <double>();
// (t, b1ef, b2ef, b3ef, b4ef, b5ef, b3ef2)
listaEfetivos.Add(t); //0
listaEfetivos.Add(b1ef); //1
listaEfetivos.Add(b2ef.ElementAt(0)); //2
listaEfetivos.Add(b3ef); //3
listaEfetivos.Add(b4ef.ElementAt(0)); //4
listaEfetivos.Add(b5ef); //5
listaEfetivos.Add(ycg); // 6, ycgEfetivo
listaEfetivos.Add(xg); //7
listaEfetivos.Add(b2ef.ElementAt(1)); //8, ds
listaEfetivos.Add(0); //9, b3ef2
// listaEfetivos.Add(Form1.xg);
return(listaEfetivos);
//return new Tuple<double, double, double, double, double, double>
// (espessura, b1ef, b2ef, b3ef, b4ef, b5ef, ycg, xg);
}
