void flexaoSimples()
{
double tensao = Form1.tensaofy;
List <double> lstLargurasEfetivasX = new List <double>();
List <double> lstPropriedadesEfetivasX = new List <double>();
lstLargurasEfetivasX = MLEPerfilUFlexaoX(this, tensao);
lstPropriedadesEfetivasX = propEfetivasPerfilU(this, lstLargurasEfetivasX, "FLEXAOX");
//areaEfetiva = lstPropriedadesEfetivasX.ElementAt(0);
if (lstLargurasEfetivasX.ElementAt(6) == Elemento3)
{
moduloWxEfetivo = 0;
mrdFlexaoSimplesx = 0;
}
else
{
moduloWxEfetivo = lstPropriedadesEfetivasX.ElementAt(1);
mrdFlexaoSimplesx = NBR.flexaoSimples(moduloWxEfetivo);
}
relatorioFLexaoSiples("X", lstLargurasEfetivasX, moduloWxEfetivo, mrdFlexaoSimplesx);
List <double> lstLargurasEfetivasY = new List <double>();
List <double> lstPropriedadesEfetivasY = new List <double>();
lstLargurasEfetivasY = MLEPerfilUFlexaoY(this, tensao);
lstPropriedadesEfetivasY = propEfetivasPerfilU(this, lstLargurasEfetivasY, "FLEXAOY");
//areaEfetiva = lstPropriedadesEfetivasY.ElementAt(0);
moduloWyEfetivo = lstPropriedadesEfetivasY.ElementAt(2);
mrdFlexaoSimplesy = NBR.flexaoSimples(moduloWyEfetivo);
relatorioFLexaoSiples("Y", lstLargurasEfetivasY, moduloWyEfetivo, mrdFlexaoSimplesy);
}
void flexaoTorcao()
{
double tensao = Form1.tensaofy;
Tuple <double, double> fatorReducao = NBR.fatorReducaoFlexao(this);
//==========================================
//Calculo da resistencia a Flexao no eixo de simetria (eixo X)
fatorReducaoFlexaoX = fatorReducao.Item1;
double tensaoFlexaoX = tensao * fatorReducaoFlexaoX;
List <double> lstLargurasEfetivasEmX = MLEPerfilUFlexaoX(this, tensaoFlexaoX);
List <double> lstPropEfetivasEmX = propEfetivasPerfilU(this, lstLargurasEfetivasEmX, "FLEXAOX");
moduloWxEfetivo = lstPropEfetivasEmX.ElementAt(2);
mrdFlexaoTorcaoX = NBR.flexaoLateralTorcao(moduloWxEfetivo, fatorReducaoFlexaoX);
relatorioFlexoTorcao("X", tensao, lstLargurasEfetivasEmX, moduloWxEfetivo, fatorReducaoFlexaoX, mrdFlexaoTorcaoX);
//==========================================
//Calculo da resistencia a Flexao no eixo perpendicular ao eixo de simetria (eixo y)
fatorReducaoFlexaoY = fatorReducao.Item2;
double tensaoFlexaoY = fatorReducaoFlexaoY * tensao;
List <double> lstLargurasEfetivasEmY = MLEPerfilUFlexaoY(this, tensaoFlexaoY);
List <double> lstPropEfetivasEmY = propEfetivasPerfilU(this, lstLargurasEfetivasEmY, "FLEXAOY");
moduloWyEfetivo = lstPropEfetivasEmY.ElementAt(2);
mrdFlexaoTorcaoY = NBR.flexaoLateralTorcao(moduloWyEfetivo, fatorReducaoFlexaoY);
relatorioFlexoTorcao("Y", tensao, lstLargurasEfetivasEmY, moduloWyEfetivo, fatorReducaoFlexaoY, mrdFlexaoTorcaoY);
NBR.verificacaoDistorcional(Espessura, Elemento1, b2, b3, "FLEXAO");
}
void distorcional()
{
if (Elemento1 != 0) //Perfil U enrijecido
{
List <double> lstDistorcionalCompressao = new List <double>();
List <double> lstDistorcionalflexao = new List <double>();
lstDistorcionalCompressao = NBR.verificacaoDistorcional(Espessura, Elemento1, Elemento2, Elemento3, "COMPRESSAO");
double almaXtComp = lstDistorcionalCompressao.ElementAt(1);
double mesaXalmaComp = lstDistorcionalCompressao.ElementAt(2);
double enrijecedorXalmaComp = lstDistorcionalCompressao.ElementAt(3);
double condicaoComp = lstDistorcionalCompressao.ElementAt(0);
relatorioDistorcionalComp(condicaoComp, almaXtComp, mesaXalmaComp, enrijecedorXalmaComp);
if (lstDistorcionalCompressao.ElementAt(0) == 1)
{
verificacaoDistorcionalCompressao = "Verificar";
}
else
{
verificacaoDistorcionalCompressao = "Dispensada";
}
lstDistorcionalflexao = NBR.verificacaoDistorcional(Espessura, Elemento1, Elemento2, Elemento3, "FLEXAO");
double almaXtFlex = lstDistorcionalflexao.ElementAt(1);
double mesaXalmaFlex = lstDistorcionalflexao.ElementAt(2);
double enrijecedorXalmaFlex = lstDistorcionalflexao.ElementAt(3);
double condicaoFlex = lstDistorcionalflexao.ElementAt(0);
relatorioDistorcionalFlex(condicaoFlex, almaXtFlex, mesaXalmaFlex, enrijecedorXalmaFlex);
if (lstDistorcionalflexao.ElementAt(0) == 1)
{
verificacaoDistorcionalFlexao = "Verificar";
}
else
{
verificacaoDistorcionalFlexao = "Dispensada";
}
}
else // Perfil U simples
{
verificacaoDistorcionalCompressao = "Dispensada";
verificacaoDistorcionalFlexao = "Dispensada";
}
}
void flambagemLocal()
{
double tensao = Form1.tensaofy;
List <double> lstLargurasEfetivas = new List <double>();
List <double> lstPropriedadesEfetivas = new List <double>();
lstLargurasEfetivas = MLEPerfilUCompressao(this, tensao);
lstPropriedadesEfetivas = propEfetivasPerfilU(this, lstLargurasEfetivas, "COMPRESSAO");
areaEfetiva = lstPropriedadesEfetivas.ElementAt(0);
areaEfetivaLocal = areaEfetiva;
rsdLocal = NBR.flambagemLocal(areaEfetivaLocal);
relatorioFlambagemLocal(lstLargurasEfetivas, tensao);
}
void compressao()
{
string solicitacao = "COMPRESSAO";
double tensao = Form1.tensaofy;
fatorReducaoCompressao = NBR.fatorReducaoCompressao(this);
double tensaoCompressao = tensao * fatorReducaoCompressao;
List <double> lstLargurasEfetivas = MLEPerfilUCompressao(this, tensaoCompressao);
List <double> lstPropEfetivas = propEfetivasPerfilU(this, lstLargurasEfetivas, solicitacao);
areaEfetiva = lstPropEfetivas.ElementAt(0);
areaEfetivaGlobal = areaEfetiva;
rsdCompressao = NBR.resistenciaCompressao(fatorReducaoCompressao, this);
relatorioCompressao(lstLargurasEfetivas, tensao);
}
public new void Dimensionar()
{
relatorioDeCalculo = "";
largurasDeCalculo();
propGeometricasPerfilU(this);
relatorioDeCalculo += "Propriedades Geométricas da seção: \r\n"
+ "Area da seção: " + area.ToString("#.##") + " cm2" + "\r\n"
+ "Momento de Inercia em X: " + iPerfilX.ToString("#.##") + " cm4" + "\r\n"
+ "Momento de Inercia em Y: " + iPerfilY.ToString("#.##") + " cm4" + "\r\n"
+ "Raio de Giração Polar:" + ro.ToString("#.##") + " cm" + "\r\n" + "\r\n" + "\r\n";
flambagemLocal();
tracao();
flexaoSimples();
compressao();
flexaoTorcao();
cortante();
distorcional();
flexaoComposta();
flexaoCortante();
indiceEsbeltez = NBR.limiteEsbeltez(this);
valoresMaximos = NBR.larguraEspessura(this);
}
void flexaoCortante()
{
condicaoFlexaoCortanteX = NBR.FlexaoECortanteX(this);
condicaoFlexaoCortanteY = NBR.FlexaoECortanteY(this);
}
void flexaoComposta()
{
condicaoFlexaoComposta = NBR.flexaoComposta(this);
}
void cortante()
{
vrdCortante = NBR.cortante(this);
relatorioCortante();
}
void tracao()
{
rsdTracao = NBR.resistenciaTracao(area);
relatorioTracao();
}
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);
}
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);
}
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);
}
//Verifica o pefil conforme a Tabela 11 e Tabela 14, Item 9.7.3 NBR 14762:2010
public static List <double> verificacaoDistorcional(double espessura, double enrijecedor, double elementoB2, double elementoB3, string solicitacao)
{
double t = espessura;
double D = enrijecedor;
double b2 = elementoB2;
double b3 = elementoB3;
double mensagem; // 1 = Não OK, 0 = OK
double almaXt = b3 / t;
double mesaXalma = b2 / b3;
double enrijecedorXmesa = D / b2;
//==========================================
//Tabela 11, NBR 14762:2010
List <double> lstAlmaXt = new List <double>();
lstAlmaXt.Add(250); lstAlmaXt.Add(200); lstAlmaXt.Add(125); lstAlmaXt.Add(100); lstAlmaXt.Add(50);
List <double> lstMesaXAlma = new List <double>();
lstMesaXAlma.Add(0.4); lstMesaXAlma.Add(0.6); lstMesaXAlma.Add(0.8); lstMesaXAlma.Add(1.0); lstMesaXAlma.Add(1.2);
lstMesaXAlma.Add(1.4); lstMesaXAlma.Add(1.6); lstMesaXAlma.Add(1.8); lstMesaXAlma.Add(2.0);
List <List <double> > lstLimites = new List <List <double> >();
if (solicitacao == "COMPRESSAO")
{
lstLimites.Add(new List <double> {
0.02, 0.03, 0.05, 0.06, 0.06, 0.06, 0.07, 0.07, 0.07
});
lstLimites.Add(new List <double> {
0.03, 0.04, 0.06, 0.07, 0.07, 0.08, 0.08, 0.08, 0.08
});
lstLimites.Add(new List <double> {
0.04, 0.06, 0.08, 0.10, 0.12, 0.12, 0.12, 0.12, 0.12
});
lstLimites.Add(new List <double> {
0.04, 0.06, 0.10, 0.12, 0.15, 0.15, 0.15, 0.15, 0.15
});
lstLimites.Add(new List <double> {
0.08, 0.15, 0.22, 0.27, 0.27, 0.27, 0.27, 0.27, 0.27
});
}
else
{
lstLimites.Add(new List <double> {
0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05
});
lstLimites.Add(new List <double> {
0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06
});
lstLimites.Add(new List <double> {
0.10, 0.10, 0.09, 0.09, 0.09, 0.09, 0.09, 0.09, 0.09
});
lstLimites.Add(new List <double> {
0.12, 0.12, 0.12, 0.11, 0.11, 0.10, 0.10, 0.10, 0.10
});
lstLimites.Add(new List <double> {
0.25, 0.25, 0.22, 0.22, 0.20, 0.20, 0.20, 0.19, 0.19
});
}
//==========================================
if (lstAlmaXt.Contains(almaXt))// verifica se a relação possui um valor igual aos indices da coluna
{
int i = lstAlmaXt.IndexOf(almaXt);
if (lstMesaXAlma.Contains(mesaXalma)) // verifica se a a relação possui um valor igual aos indices da linha
{
int j = lstMesaXAlma.IndexOf(mesaXalma);
if (lstLimites.ElementAt(i).ElementAt(j) > enrijecedorXmesa) // verifica se a relação do perfil é inferior ao da tabela
{
mensagem = 1; //caso seja inferior, mensagem será "nao ok"
}
else
{
mensagem = 0;
} // caso seja superior, mensagem sera "ok"
}
else // caso a relação nao seja igual a da linha, sera feita a interpolação
{
int j1 = NBR.interpLstDistMesaAlma(lstMesaXAlma, mesaXalma).Item1;
int j2 = NBR.interpLstDistMesaAlma(lstMesaXAlma, mesaXalma).Item2;
if (j1 == j2) //caso a interpolação obtenha o mesmo indice, valor menor que o primeiro indice ( valor menor que 0,4)
{
double referencia = lstLimites.ElementAt(i).ElementAt(j1);
if (referencia > enrijecedorXmesa)// verifica se a relação do perfil é inferior ao da tabela
{
mensagem = 1;
} //caso seja inferior, mensagem será "nao ok"
else
{
mensagem = 0;
} // caso seja superior, mensagem sera "ok"
}
else
{
double deltaSup = //variação entre indices de linha
Math.Abs(lstMesaXAlma.ElementAt(j1) - lstMesaXAlma.ElementAt(j2));
double deltaInf = //variação entre valores minimos
Math.Abs(lstLimites.ElementAt(i).ElementAt(j1) - lstLimites.ElementAt(i).ElementAt(j2));
double referencia = // valor interpolado - (valor maior - relação) * (variação por unidade) + valor minimo do maior indice
Math.Abs((lstMesaXAlma.ElementAt(j1) - mesaXalma) * (deltaInf / deltaSup) - lstLimites.ElementAt(i).ElementAt(j1));
if (referencia > enrijecedorXmesa) // verifica se a relação do perfil é inferior ao da tabela
{
mensagem = 1;
} //caso seja inferior, mensagem será "nao ok"
else
{
mensagem = 0;
} // caso seja superior, mensagem sera "ok"
}
}
}
else //interpolar indice de coluna
{
int i1 = NBR.interpListDistAlmaT(lstAlmaXt, almaXt).Item1;
int i2 = NBR.interpListDistAlmaT(lstAlmaXt, almaXt).Item2;
int j;
if (lstMesaXAlma.Contains(mesaXalma)) //se relação mesa x alma esta contido no indice de linha
{
j = lstMesaXAlma.IndexOf(mesaXalma);
}
else // valores de indices de linha interpolados
{
int j1 = NBR.interpLstDistMesaAlma(lstMesaXAlma, mesaXalma).Item1;
int j2 = NBR.interpLstDistMesaAlma(lstMesaXAlma, mesaXalma).Item2;
if (j1 == j2)
{
j = j1;
}
else
{
j = j2;
}
}
if (i1 == i2) // caso a realção tenha valor menor ou maior que o indice
{
double referencia = lstLimites.ElementAt(i1).ElementAt(j);
if (referencia > enrijecedorXmesa)
{
mensagem = 1;
}
else
{
mensagem = 0;
}
}
else //interpolação dos valores
{
double deltaSup = Math.Abs(lstAlmaXt.ElementAt(i2) - lstAlmaXt.ElementAt(i1)); //delta coluna
double deltaInf = Math.Abs((lstLimites.ElementAt(i2)).ElementAt(j) - (lstLimites.ElementAt(i1)).ElementAt(j));//delta linha
double referencia = (lstAlmaXt.ElementAt(i2) - almaXt) * (deltaInf / deltaSup) + (lstLimites.ElementAt(i2)).ElementAt(j);
if (referencia > enrijecedorXmesa)
{
mensagem = 1;
}
else
{
mensagem = 0;
}
}
}
List <double> retorno = new List <double>();
retorno.Add(mensagem); retorno.Add(almaXt); retorno.Add(mesaXalma); retorno.Add(enrijecedorXmesa);
return(retorno);
}
