/*
Rotinas Para Cálculo de Viga Bi Apoiada
Por Marcelo Adorni Pereira  V.0.1 (28/07/02)
R&M ENGENHARIA S/C LTDA
Todos os Direitos Resevados
*/
//###############################################
// Variáveis Globais 	
var FY     = 5000.0
var FCK    = 150.0
var GC     = 1.40
var GS     = 1.15
var GF     = 1.40
var FYD    = parseFloat(FY/GS)
var FCD    = parseFloat(FCK/GC) 
var EC     = 3.50
var EY     = parseFloat(FYD/2100.0)
var QSI0   = parseFloat(EC/(EC+EY))
var S0     = parseFloat(0.8*QSI0)
var FI0    = parseFloat(1-(S0/2.0))
var MI0    = parseFloat(0.85*S0*FI0)
var LinhaN = 0.0
var MAD    = 0.0
var MO     = 0.0
var MP     = 0.0
var MM     = 0.0
var A1     = 0.0  // Armadura Inferior Simples
var A2     = 0.0  // Armadura Superior
var AT     = 0.0 // Armadura Inferior
var SF     = 0.0 // Area de Aco Estribos
var CMAX   = 0.0 // Carga Maxima

//###############################################
// Calculo do Momento Admissível
function MomentoAd() {
var B = document.Entradas.baseB.value
var B = parseFloat(B)
var H = document.Entradas.AlturaH.value
var H = parseFloat(H)
var D = parseFloat(H - 2.0)
var X    = parseFloat(QSI0*D)
var Y    = parseFloat(0.8*X)
var Z    = parseFloat(D-(Y/2.0))
var M1R  = parseFloat(MI0*B*D*D*FCD)
    MAD  = parseFloat(M1R/(100*GF))
return MAD
}		

//###############################################
// Calculo do Momento Fletor
 function MomentoFletor() {
	var L  = document.Entradas.ComprimentoL.value
	L  = parseFloat(L)
	var CD = document.Entradas.CDistribuida.value
	CD = parseFloat(CD)
	var CC = document.Entradas.CConcentrada.value
	CC = parseFloat(CC)
	var PC = document.Entradas.XdaCC.value
	PC = parseFloat(PC)
	if(PC<=0) { PC = 0.01 }
	if(PC>=L) { PC = parseFloat(L-0.01) }
    MO = parseFloat((CD*L*L)/8.0)
    MP = parseFloat(CC*PC*(L-PC)/L)
	MM = parseFloat(MO+MP)
	return MM
} 

//###############################################
// Calculo do AS
function CAS() {
 var MM  = MomentoFletor()
 var MAD = MomentoAd()
 var B = document.Entradas.baseB.value
 var B = parseFloat(B)
 var H = document.Entradas.AlturaH.value
 var H = parseFloat(H)
 var D = parseFloat(H - 2.0)
 var MD = parseFloat(GF*MM*100.0)
 if(MM<=MAD) {
 	 var A   = parseFloat(MD/(B*FCD*D*D))
 	 var S   = parseFloat(1.0-(Math.sqrt(1.0-2.0*A)))
 	 var FI  = parseFloat(1.0-S/2.0)
 	 var Y   = parseFloat(S*D)
 	 LinhaN  = Y
 	 var MI  = parseFloat(0.85*S*FI)
 	 var A1  = parseFloat(MD/(FI*FYD*D))
 	 var AM  = parseFloat(0.043*FCD*B*D/FYD)
 	 var AM1 = parseFloat(0.15*B*H/100)
 	 if(A1<AM1) { A1=AM1 }
 	 A2 = 0.0
 	 AT = 0.0
 	 return A1
 }// if do MM<=MAD
 if(MM>MAD) { 
 	 var CF   = parseFloat(D-2.0)
 	 var M1R  = parseFloat(MI0*B*D*D*FCD)
 	 var A    = parseFloat(M1R/(B*FCD*D*D))
 	 var S    = parseFloat(1.0-Math.sqrt(1.0-2.0*A))
 	 var FI   = parseFloat(1.0-S/2.0)
 	 var MI   = parseFloat(0.85*S*FI)
 	 var M2R  = parseFloat(MD-M1R)
 	 A2   = parseFloat(M2R/(FYD*CF))
 	 AT   = parseFloat(M1R/(FI*FYD*D)+A2)
 	 A1   = 0.0	 
 	 return AT 
 }// if do MM>MAD  
}

//###############################################
// Função Para Cálculo das Reações de Apoio

function ApoioA() {
	var L  = document.Entradas.ComprimentoL.value
	L  = parseFloat(L)
	var CD = document.Entradas.CDistribuida.value
	CD = parseFloat(CD)
	var CC = document.Entradas.CConcentrada.value
	CC = parseFloat(CC)
	var PC = document.Entradas.XdaCC.value
	PC = parseFloat(PC)
	if(PC<=0) { PC = 0.01 }
	if(PC>=L) { PC = parseFloat(L-0.01) }
	var RA = parseFloat(CD*L/2.0)
	var MP = parseFloat(CC*PC*(L-PC)/L)
	var A  = parseFloat(RA+MP/PC)
	return A
}

//###############################################
// Função Para Cálculo das Reações de Apoio
function ApoioB() {
	var L  = document.Entradas.ComprimentoL.value
	L  = parseFloat(L)
	var CD = document.Entradas.CDistribuida.value
	CD = parseFloat(CD)
	var CC = document.Entradas.CConcentrada.value
	CC = parseFloat(CC)
	var PC = document.Entradas.XdaCC.value
	PC = parseFloat(PC)
	if(PC<=0) { PC = 0.01 }
	if(PC>=L) { PC = parseFloat(L-0.01) }
	var RA = parseFloat(CD*L/2.0)
	var MP = parseFloat(CC*PC*(L-PC)/L)
	var B  = parseFloat(RA+MP/(L-PC))
	return B
}
 
//###############################################
// Função Para Cálculo do Cisalhamento
function Cisalha() {
 var B    = document.Entradas.baseB.value
 var B    = parseFloat(B)
 var H    = document.Entradas.AlturaH.value
 var H    = parseFloat(H)
 var D    = parseFloat(H - 2.0)
 CMAX = parseFloat(19.0*B*D)
 var Q1   = parseFloat(ApoioA())
 var Q2   = parseFloat(ApoioB())
 if( Q1 >= Q2 ) { var Q = parseFloat(Q1) }
 if( Q2 >= Q1 ) { var Q = parseFloat(Q2) }
 var T = parseFloat(Q/B/D)
 if ( T >= 19.0 ) { alert("Cisalhamento Maior que Admissível") }
 SF=parseFloat((Q-3.9*B*D)/(27.0*D)) 
 if (SF<0) { SF = parseFloat(B*0.14) }
 var tmp = parseFloat(B*0.14)
 if (SF<tmp) { SF = parseFloat(B*0.14)  }
 return T 
}

//#############################################################
// Verifica se Todos os Dados de Entrada Estão Adequados
function VerificaDADOS() {
   var B = document.Entradas.baseB.value
   B = parseFloat(B)
   if(B<=0)  { alert("Por favor entre com o valor de B outra vez") }
   if(B>100) { alert("Dimensão Máxima para Base = 100cm") }
   if(B<10)  { document.Entradas.baseB.value = 10 
   	           alert("Valor Mínimo para B = 10cm") }
   if(isNaN(B)) { alert("Por favor entre com o valor de B outra vez") }
   var H = document.Entradas.AlturaH.value
   H = parseFloat(H)
   if(isNaN(H)) { alert("Por favor entre com o valor de H outra vez") }
   if(H<=0)     { alert("Por favor entre com o valor de H outra vez") }
   if(H>100)    { alert("Dimensão Máxima para Altura H = 100cm") }
   if(H<20)     { document.Entradas.AlturaH.velue = 20
   	              alert("Altura da Viga Deve Ser No Mínimo 20cm, Será Alerado!")
                }
   var L = document.Entradas.ComprimentoL.value
   L = parseFloat(L)
   if(isNaN(L)) { alert("Por favor entre com o valor de L outra vez") }
   if(L<=0)     { alert("Por favor entre com o valor de L outra vez") }
   if(L>1000)   { alert("Dimensão Máxima para L = 1000cm") }
   var tmp = parseFloat(L*100/15.0)
   if(H<tmp) { H = Math.ceil(tmp) 
   	   alert("Altura da Viga, sob estas condições, deverá ser no Mínimo de "+H+"cm")
   	   if(H>20 && H<25) { H=25.0 }
   	   if(H>25 && H<30) { H=30.0 }
   	   if(H>30 && H<35) { H=35.0 }
   	   if(H>35 && H<40) { H=40.0 }
   	   if(H>40 && H<45) { H=45.0 }
   	   if(H>45 && H<50) { H=50.0 }
   	   if(H>50 && H<55) { H=55.0 }
   	   if(H>55 && H<60) { H=60.0 }
   	   if(H>60 && H<65) { H=65.0 }
   	   if(H>65 && H<70) { H=70.0 }
   	   if(H>70 && H<75) { H=75.0 }
   	   if(H>75 && H<80) { H=80.0 }
   	   if(H>80 && H<85) { H=85.0 }
   	   if(H>85 && H<90) { H=90.0 }
   	   if(H>90 && H<95) { H=95.0 }
   	   if(H>95 && H<100){ H=100.0}
   document.Entradas.AlturaH.value = H }
   var CC = document.Entradas.CConcentrada.value
   CC = parseFloat(CC)
   if(isNaN(CC)) { alert("Por favor entre com o valor da CC outra vez") }
   if(CC<0) { alert("Por favor entre com o valor da CC outra vez") }
   var CD = document.Entradas.CDistribuida.value
   CD = parseFloat(CD)
   if(isNaN(CD)) { alert("Por favor entre com o valor da CD outra vez") }
   if(CD<0) { alert("Por favor entre com o valor da CD outra vez") }
   var PX = document.Entradas.XdaCC.value
   PX = parseFloat(PX)
   if(isNaN(PX)) { alert("Por favor entre com a Poxição X outra vez") }
}

//#######################################################################
// Função Para Determinar Quantidade de Ferros
function FerrosA1() {
	if(A1<=0) { alert("Verifique os Dados, Viga Não Dimensionada!!")
		        return "Não Calculado"
	          }
	if(1.42>=A1) { return "2x#10mm"   } // 2x3/8"
	if(2.13>=A1) { return "3x#10mm"   } // 3x3/8"
	if(2.54>=A1) { return "2x#12.5mm" } // 2x1/2"
	if(3.81>=A1) { return "3x#12.5mm" } // 3x1/2"
	if(5.08>=A1) { return "4x#12.5mm" } // 4x1/2"
	if(5.94>=A1) { return "3x#16mm"   } // 3x5/8"
	if(7.92>=A1) { return "4x#16mm"   } // 4x5/8"
	if(9.90>=A1) { return "5x#16mm"   } // 5x5/8"
	if(11.4>=A1) { return "4x#20mm"   } // 4x3/4"
	if(14.25>=A1) { return "5x#20mm"  } // 5x3/4"
	if(17.10>=A1) { return "6x#20mm"  } // 6x3/4"
	if(19.95>=A1) { return "7x#20mm"  } // 7x3/4"	
	else { alert("[1]Este Programa Não Pode Dimensionar sua Viga!! A1="+A1)
		   alert("Verifique os Dados! Ou Entre em Contado pelo E-mail")
		   	    return "Indefinido!!" }
}

function FerrosA2() {
	if(A2==0) { return "2x#8mm" }
	if(1.42>=A2) { return "2x#10mm"   } // 2x3/8"
	if(2.13>=A2) { return "3x#10mm"   } // 3x3/8"
	if(2.84>=A2) { return "4x#10mm"   } // 4x3/8"
	if(3.81>=A2) { return "3x#12.5mm" } // 3x1/2"
	if(5.08>=A2) { return "4x#12.5mm" } // 4x12.5"
	if(5.94>=A2) { return "3x#16mm"   } // 3x5/8"
	if(7.92>=A2) { return "4x#16mm"   } // 4x5/8"
	if(8.55>=A2) { return "3x#20mm"   } // 3x3/4"
	if(11.4>=A2) { return "4x#20mm"   } // 4x3/4"
	if(14.3>=A2) { return "5x#20mm"   } // 5x3/4"
	else { alert("[2]Este Programa Não Pode Dimensionar sua Viga!! A2="+A2)
		   alert("Verifique os Dados! Ou Entre em Contado pelo E-mail")
		   	    return "Indefinido!!" }
}

//#############################################################
// Função para Determinação dos Estribos
function Estribos() {
	if(SF<=0) { alert("[3]Este Programa Não Pode Dimensionar sua Viga!!")
		        return "Indefinido!!" }
    var tmp = parseFloat(SF/2.0)
    if(0.95>=tmp) { return "#5mm C/20cm" }  // #0.19cm2
    if(1.33>=tmp) { return "#5mm C/15cm" }
    if(1.90>=tmp) { return "#5mm C/10cm" }
	if(2.28>=tmp) { return "#5mm C/8cm"  }	
    if(2.88>=tmp) { return "#6.3mm C/12cm" }// #0.32cm2
    if(3.20>=tmp) { return "#6.3mm C/10cm" }
	if(3.84>=tmp) { return "#6.3mm C/8cm"  }
    if(4.08>=tmp) { return "#8mm C/12cm" } // #0.49cm2
    if(4.90>=tmp) { return "#8mm C/10cm" }
    if(6.13>=tmp) { return "#8mm C/8cm"  } 
	else { alert("[4]Este Programa Não Pode Dimensionar sua Viga!! SF= "+SF)
		   return "Indefinido!!" }
}

// #####################################################################
// Format num com precis casas Decimais	
function formatar(num,precis) { 
var tmp2 = Math.floor(num)
precis =   Math.pow(10.0,precis)
var tmp1 = Math.floor((num-tmp2)*precis)
return tmp2+"."+tmp1
}

//#############################################################
// Função Principal Para Dimensionar Viga BiApoiada
function VigaBi() {
VerificaDADOS()
document.Resultados.MomentoA.value  = Math.ceil(MomentoAd())+".0"
if(MAD<MomentoFletor()) { alert(" ATENÇÃO!! Momento Fletor Maior que Admissível ")
	                      alert(" Situação Não Recomendada")
	                      alert("Dimensionamento Exige Armadura Dupla! ") }
document.Resultados.MomentoF.value  = Math.ceil(MomentoFletor())+".0"
A1 = CAS()
document.Armaduras.Ainferior.value  = FerrosA1()
document.Armaduras.Asuperior.value  = FerrosA2()
var B  = document.Entradas.baseB.value
	B  = parseFloat(B)
if(LinhaN>=B || LinhaN<=0) { document.Resultados.Lneutra.value = "Indef." }
else { document.Resultados.Lneutra.value   = formatar(LinhaN,4.0)         }
document.Resultados.ReacA.value     = Math.ceil(ApoioA())+".0"
document.Resultados.ReacB.value     = Math.ceil(ApoioB())+".0"
document.Resultados.TensaCisa.value = formatar(Cisalha(),4.0)
document.Resultados.CargaMax.value  = Math.ceil(CMAX)+".0"
document.Armaduras.Estribos.value  = Estribos()
}