#include<iostream>

#include<cstdlib>

#include<conio.h>

#include<math.h>

using namespace std;

int main()

{int salir,elemento_estructural;

/// comamdo para cambiar color de fondo y letra

system("COLOR F1");

do{

MENU:

system("CLS");
cout << "===============================================================================" << endl

<< "================== UNIVERSIDAD NACIONAL PEDRO RUIZ GALLO ====================" << endl

<< "================= ESCUELA PROFESIONAL DE INGENIERIA CIVIL ===================" << endl

<< "====================- CONCRETO ARMADO I =============================" << endl

<< "================ PREDIMENSIONADO DE ELEMENTOS ESTRUCTURALES ===================" << endl

<< "===============================================================================" << endl;

cout <<"\n \n \n";

///DECLARACION DE VARIABLES PRINCIPALES

int elemento_estructural;

///TIPO ELEMENTO A PREDIMENSIONAR

cout <<"\t ==> ESCOJA QUE ELEMENTO ESTRUTURAL DESEA PREDIMENSIONAR: \n\t\t\t" << endl

<<"\t\t\t\t 1)LOSAS\n\t\t\t" << endl

<<"\t\t\t\t 2)VIGAS \n\t\t\t" << endl

<<"\t\t\t\t 3)COLUMNAS \n\t\t\t"<< endl

 <<"\t\t\t\t 4)PLACAS \n\t\t\t" << endl

<<"\t\t\t\t 5)SALIR\n" << endl;

cout <<"\t\t\t INGRESE OPCION :\t"; cin >>elemento_estructural;

cout <<"\t\t\t \n";

if (elemento_estructural>=6)

goto MENU;

};

switch (elemento_estructural) {

case 1:

int Volver_dimensionar_losa;

do{

system("CLS");
cout << "===============================================================================" << endl

<< "===================== PREDIMENSIONADO DE LOSAS =======================" << endl

<< "===============================================================================" << endl;

cout <<"\n \n";

float tipo_losa,Luz,peralte_aligerado,peralte_aligerado_comercial,peralte_maciza,espesor_losa,altura_ladrillo;

cout <<"\t\t\t ESCOJA EL TIPO DE LOSA\n\n\t\t\t 1)Losa aligerada\n\n\t\t\t 2)Losa maciza\n\n";

cout <<"\n\t\t\t DIGITE LA OPCION: ";cin >>tipo_losa;

cout <<"\t\t\t \n\n";

cout <<"\t\t\t INGRESE LA LUZ LIBRE \n\n\t\t\t Ln(metros)= ";

cin >>Luz;

cout <<"\t\t\t \n";

system("CLS");

int REDONDEO;

cout <<"\t\t\t \n";

cout<<" ******************************************************************************\n";

cout<<" ******************** RESULTADOS PREDIMESIONADO DE LOSA ***********************\n";

 cout<<" ******************************************************************************\n";

cout <<"\t\t\t \n";

if(tipo_losa==1)

{ peralte_aligerado=Luz*100/25;

///*REDONDEO DE PERALTE DE LOSA

///aproxima a la los peraltes de losa conocidos 15,17,20,25,30,35,40

if(peralte_aligerado<=17) peralte_aligerado_comercial=17;

if(peralte_aligerado>17 && peralte_aligerado<=20) peralte_aligerado_comercial=20;

if(peralte_aligerado>20 && peralte_aligerado<=25) peralte_aligerado_comercial=25;

if(peralte_aligerado>25 && peralte_aligerado<=30) peralte_aligerado_comercial=30;

espesor_losa=5;

///ALTURA DE LADRILLO

altura_ladrillo=peralte_aligerado_comercial-5;
 cout<<"\t ::> TIPO DE LOSA: ALIGERARA \n\n";

cout<<"\t ::> LUZ LIBRE: :\t"<<Luz<<" "<<"metros\n\n";

cout<<"\t ::> PERALTE DE LOSA ALIGERADA :\t"<<peralte_aligerado<<" "<<"centimetros\n\n";

cout<<"\t ::> SE RECOMIENDA USAR : \n\n";

if(peralte_aligerado>30){

cout<<"\t::: LOSA MACIZA POR SER EXCESIVO EL PERALTE !\n\n";}

else {

cout<<"\t PERALTE DE LOSA ALIGERADA USO COMUN :\t"<<peralte_aligerado_comercial<<" "<<"centimetros\n";

cout<<"\t ESPESOR DE LOSA ALIGERADA :\t"<<espesor_losa<<" "<<"centimetros\n";

cout<<"\t ALTURA DE LADRILLO DE TECHO :\t"<<altura_ladrillo<<" "<<"centimetros\n";

};

else

{ peralte_aligerado=Luz/35;

///*REDONDEO DE PERALTE DE LOSA

 REDONDEO=ceil(peralte_aligerado*100);

peralte_maciza=REDONDEO;

cout<<"\t ::> TIPO DE LOSA: MACIZA \n\n";

cout<<"\t ::> LUZ LIBRE: :\t"<<Luz<<" "<<"metros\n\n";

cout<<"\t ::> PERALTE DE LOSA MACIZA ES:\t"<<peralte_maciza<<" "<<"centimetros\n\n";

};

cout<<"\t\t \n";

cout<<" ==============================================================================\n";

cout<<" ==============================================================================\n";

///VOLVER A DIMENSIONAR OTRA LOSA

cout <<"\t\t\t \n";

cout <<"\t DESEA DIMENSIONAR OTRA LOSA ?\n\t\t\t" << endl

 <<"\t 1) SI, Dimensionar nuevamente\n\t\t\t" << endl

<<"\t 2) ir al MENU PRINCIPAL\n\t\t\t" << endl;

cout <<"\t \n";

cout <<"\t Digite el NUMERO de opcion :\t"; cin >>Volver_dimensionar_losa;

cout <<"\t\t\t \n";

}while(Volver_dimensionar_losa==1);

goto MENU;

break;

///
===============================================================================================================================
============

///=================== VIGAS ======================================================= VIGAS

===================================================

///
===============================================================================================================================
============
 case 2:

int Volver_dimensionar;

do{

system("CLS");

/*ingreso de datos del tipo de losa */

/*las siguientes variables se usaran para definir los datos de entrada y salida:

B = ANCHO TRIBUTARIO

BAD= ancho tributario adicional

BX= B asterisco

PAL=peso del aligerado

PT=peso de tabiqueia

PAC=peso de acabados

SC=sobrecarga

PU=caraga del muro por metro lineal

WU=carga distribuida por metro cuadrado

b=base de viga

h=PERALTE DE VIGA

Muro= condicion de existencia de muro 1=SI 2=NO

 pum=peso unitario del muro

Hm=altura del muro

Em=espesor de muro

Ln=LUZ LIBRE

a=alfa

Sismo= condicion de zona sismica 1=REGULAR 2=ALTA

Tipo= condicion del TIPO DE USO : 1=vivivienda 2 =ofic.edif.depto 3=garajes tiendas 4= depositos A 5=depositos B

*/

VIGAS:

cout << "*******************************************************************************" << endl

<< "************************ PREDIMENSIONADO DE VIGAS *****************************" << endl

<< "*******************************************************************************" << endl;

cout <<"\n \n";

///DEFINICION DE VARIABLES

float B,B_adicional,B_asterisco,PAL,PT,PAC,SC,PU,WU,b1,h1,pum,Hm,Em,Luz,alfa,Sismo;

int Tipo,Muro;
///INGRESO DE DATOS

cout <<"\t INTRODUCCION DE DATOS\n";

cout <<"\t\t\t \n";

cout <<"\t\t DIGITE el longitud de LUZ LIBRE Ln(m) :"; cin >>Luz;

cout <<"\n\t\t DIGITE el ANCHO TRIBUTARIO B(m) :"; cin >>B;

cout <<"\t\t\t \n";

TIPO_USO:

cout <<"\n \n \n";

cout <<"\t\t TIPO DE USO DE LA EDIFICACION\n\t\t\t" << endl

<<"\t\t\t 1)Vivienda\n\t\t\t" << endl

<<"\t\t\t 2)Oficinas y Departamentos \n\t\t\t" << endl

<<"\t\t\t 3)Garajes y tiendas \n\t\t\t"<< endl

<<"\t\t\t 4)Depositos A: (Bibliotecas) \n\t\t\t" << endl

<<"\t\t\t 5)Depositos B almacenaje pesado \n\t\t\t" << endl;

cout <<"\t\t DIGITE el NUMERO de opcion :\t"; cin >>Tipo;

cout <<"\t\t\t \n\n\n";

///MARCA ERROR SI NO INGRESA UNA DE LAS OPCIONES

 if (Tipo>5)

system("CLS");

goto TIPO_USO;

};

///ANALISA EL TIPO DE ESTRUCTURA PARA DETERMINAR: SOBRECARGA Y ALFA

switch (Tipo)

{ case 1:

SC=200;

alfa=13;

break;

case 2:

SC=250;

alfa=12;

break;

case 3:
 SC=500;

alfa=11;

break;

case 4:

SC=750;

alfa=10;

break;

case 5:

SC=1000;

alfa=9;

break;

};

///MURO DE ALBAÑILERIA

system("CLS");
EXISTE_MURO:

cout <<"\t\n\n \n";

cout <<"\t\t EXISTE MURO DE ALBANILERIA sobre la VIGA ? \n\n\t\t\t" << endl

<<"\t\t\t 1)SI\n\n\t\t\t" << endl

<<"\t\t\t 2)NO \n\n\t\t\t" << endl;

cout <<"\t\t\t DIGITE el NUMERO de opcion :\t"; cin >>Muro;

///MARCA ERROR SI NO INGRESA UNA DE LAS OPCIONES

if (Muro>2 )

system("CLS");

goto EXISTE_MURO;

};

if (Muro==1) {

system("CLS");

cout <<"\t\t\t \n";

cout <<"\t\t\t DATOS DEL MURO \n";

cout <<"\t\t\t \n";

cout <<"\t\t DIGITE el PESO UNITARIO (kg/m3) =\t"; cin >>pum;

cout <<"\t\t DIGITE la ALTURA (m) =\t"; cin >>Hm;

cout <<"\t\t DIGITE el ESPESOR (m) =\t"; cin >>Em;

cout <<"\t\t\t \n";

cout <<"\t\t\t LAS CARGAS DE LA ESTRUCTURA \n";

cout <<"\t\t\t \n";

cout <<"\t\t DIGITE el PESO de ALIGERADO (kg/m2) =\t"; cin >>PAL;

cout <<"\n\t\t DIGITE el PESO de TABIQUERIA (kg/m2)=\t"; cin >>PT;

cout <<"\n\t\t DIGITE el PESO de ACABADOS (kg/m2) =\t"; cin >>PAC;

system("CLS");

cout <<"\t\t\t \n";

///CALCULA EL ANCHO TRIBUTARIO ADICIONAL

PU=pum*Hm*Em;

WU=PAL+PT+PAC+SC;

B_adicional=PU/WU;
 ///DETERMINA EL ANCHO TRIBUTARIO FINAL

B_asterisco=B+B_adicional; }

else {

B_asterisco=B;

///CALCULO DE BASE DE VIGA en cm

b1=B_asterisco/20*100; /*multiplicamos por 100 para obtener b y h en CENTIMETROS y asi porde redondear*/

///CALCULO DEL PERALTE DE VIGA en cm

h1=Luz/alfa*100;

///ZONA SISMICA ALTA O REGULAR

int SISMO;

float b_final,h_final,b2,h2;/*variables de bases y peraltes*/

///ANALISA SI CUMPLE LA NORMA? base de viga minimo 25cm:

if (b1<25)

{ cout <<"\t\t\t \n";

cout<<"\t\t EN QUE TIPO DE ZONA SISMICA SE UBICA LA ESTRUCTURA?\n";

cout <<"\t\t\t \n";

cout<<"\t\t\t 1) ALTA actividad SISMICA\n";

cout<<"\t\t\t 2) REGULAR actividad SISMICA\n";

cout <<"\t\t\t \n";

cout <<"\t\t\tDIGITE el NUMERO de opcion :\t"; cin >>SISMO;

b2=25;

if(SISMO==1){h2=pow((b1*pow(h1,3)/b2),(0.33333));} ///CRITERIO DE RIGIDEZ

else h2=sqrt(b1*pow(h1,2)/b2); ///CRITERIO DE CUANTIA

else {b2=b1; h2=h1;};

///REDONDEO DE DIMENSIONES DE VIGA

/*redondea al inmediato superior multiplo de 5*/

///REDONDEO DE BASE DE VIGA

int REDONDEO_BASE,DIVISOR,REDONDEO_PERALTE;

DIVISOR=5; ///buscar el multplo de 5 mas cercano superior

REDONDEO_BASE=ceil(b2); ///redondea al inmediato superior

while(REDONDEO_BASE%DIVISOR != 0) ///*mientras REDONDEO no sea multiplo de DIVISOR, REDONDEO seguira aumentando en 1

REDONDEO_BASE=REDONDEO_BASE+1;

b_final=REDONDEO_BASE; /*asignamos el numero entero multiplo de 5 mas cerca al entero*/

///REDONDEO DE PERALTE DE VIGA

DIVISOR=5;

REDONDEO_PERALTE=ceil(h2);
 while(REDONDEO_PERALTE%DIVISOR != 0)

REDONDEO_PERALTE=REDONDEO_PERALTE+1;

h_final=REDONDEO_PERALTE;

///IMPRESION DE RESULTADOS

system ("CLS"); //limpiar pantalla */

cout<<" ******************************************************************************\n";

cout<<" ******************** RESULTADOS PREDIMESIONADO DE VIGA ***********************\n";

cout<<" ******************************************************************************\n";

cout <<" \n\n";

cout<<"\t\t DIMENSIONES SIN REDONDEO "<<endl;

cout <<"\t\t___________________________ \n\n";

cout<<"\t\t* BASE 0 :"<<b1<<" cm\n";

cout<<"\t\t* PERALTE 0 :"<<h1<<" cm\n\n\n";

cout<<"\t\t DIMENSIONES CON REDONDEO "<<endl;

cout <<"\t\t___________________________ \n\n";

cout<<"\t\t* BASE de viga :"<<b_final<<" cm\n";

cout<<"\t\t* PERALTE de viga :"<<h_final<<" cm\n";

cout <<"\t\t\t\t \n\n";

cout<<"\t\t\t SECCION DE VIGA "<<endl;

cout << "\t _______ " << endl

<< "\t | | " << endl

<< "\t |ø ø| " << endl

<< "\t | | "<<h_final<<"cm"<<" " << endl

<< "\t | | " << endl

<< "\t |ø ø| " << endl

<< "\t |_______| " << endl

<< "\t "<<b_final<<"cm"<<" " << endl;

 cout <<"______________________________________________________________________________";

cout <<"\t\t\t \n";

///CAMBIO DE SECCION DE VIGA

float cambio_seccion;

cout <<"\t DESEA CAMBIAR DIMESIONES DE VIGA ? \n\t\t\t" << endl;

cout <<"\t\t\t1)SI" <<"\t 2)NO \n\t\t\t" << endl;

cout <<"\t\t DIGITE el NUMERO de opcion :"; cin >>cambio_seccion;

cout <<"\t\t\t \n";

 ETIQUETA_CAMBIO_SEC:

if (cambio_seccion==1) {

///PEDIR PARAMETRO A DIMENSIONAR///PEDIR PARAMETRO A DIMENSIONAR///PEDIR

PARAMETRO A DIMENSIONAR///PEDIR PARAMETRO A DIMENSIONAR///PEDIR PARAMETRO A DIMENSIONAR

system("CLS");

int PARAMETRO;

cout <<"\t\t\t\n\n\n\n\n\n \n";

cout <<"\t\t QUE PARAMETRO DESEA MODIFICAR? \n\n ";

cout<<"\t\t\t 1)BASE" ;

cout<<"\n\n\t\t\t 2)PERALTE \n \n" << endl;

cout <<"\t\t DIGITE el NUMERO de OPCION :"; cin >>PARAMETRO;

////******PARAMETRO BASE*********PARAMETRO BASE*********PARAMETRO BASE*********PARAMETRO BASE*******PARAMETRO

BASE*******PARAMETRO BASE*******PARAMETRO BASE***

if (PARAMETRO==1)

{
 system("CLS");

cout <<"\t\t\t\n\n\n\n\n\n \n";

cout <<"\t\t DIGITE LA BASE DE LA SECCION REQUERIDA\n ";

cout <<" \n";

cout <<"\t\t\t b(cm)= "; cin >>b2;

cout <<" \n";

if (b2<25) {///NORMA: BASE MINIMA 25

b2=25;

cout<<"\t\tNORMA: BASE MINIMA 25cm\n";

};

///TIPO DE ZONA SISMICA QUE DESEA UTILIZAR

cout <<"\t\t\t \n";

cout<<"\t\t EN QUE TIPO DE ZONA SISMICA SE UBICA LA ESTRUCTURA?\n";

cout <<"\t\t\t \n";

cout<<"\t\t\t 1) ALTA actividad SISMICA\n";

cout<<"\t\t\t 2) REGULAR actividad SISMICA\n";

cout <<"\t\t\t \n";

 cout <<"\t\t\tDIGITE el NUMERO de OPCION :\t"; cin >>SISMO;

if(SISMO==1){///CRITERIO DE RIGIDEZ

h2=pow((b1*pow(h1,3)/b2),(0.3333));

else { ///CRITERIO DE CUANTIA

h2=sqrt(b1*pow(h1,2)/b2);

};

system("CLS");

cout <<" \n";

/// se podria agregar una funcion RETURN o GOTO ?? en vez repetir codigo.

/*****************************************************************************************************************/

///REDONDEO DE DIMENSIONES DE VIGA

 /*redondea al inmediato
superior multiplo de 5*/

///REDONDEO DE BASE DE
VIGA

int
REDONDEO_BASE,DIVISOR,REDONDEO_PERALTE;

DIVISOR=5;
///buscar el multplo de 5 mas cercano superior

REDONDEO_BASE=ceil(b2);
///redondea al inmediato superior

while(REDONDEO_BASE
%DIVISOR != 0) ///*mientras REDONDEO no sea multiplo de DIVISOR, REDONDEO seguira aumentando en 1

REDONDEO_BASE=REDONDEO_BASE+1;

b_final=REDONDEO_BASE;
/*asignamos el numero entero multiplo de 5 mas cerca al entero*/

///REDONDEO DE PERALTE
DE VIGA
 DIVISOR=5;

REDONDEO_PERALTE=ceil(h2);

while(REDONDEO_PERALTE
%DIVISOR != 0)

REDONDEO_PERALTE=REDONDEO_PERALTE+1;

h_final=REDONDEO_PERALTE;

///IMPRESION DE RESULTADOS

system ("CLS"); //limpiar pantalla

*/

cout<<"
******************************************************************************\n";
 cout<<" ********************
RESULTADOS PREDIMESIONADO DE VIGA ***********************\n";

cout<<"
******************************************************************************\n";

cout <<" \n\n";

cout<<"\t\t DIMENSIONES SIN

REDONDEO "<<endl;

cout <<"\t\
t___________________________ \n\n";

cout<<"\t\t* BASE
0 :"<<b1<<" cm\n";

cout<<"\t\t* PERALTE
0 :"<<h1<<" cm\n\n\n";

cout<<"\t\t* BASE
2 :"<<b2<<" cm\n";

cout<<"\t\t* PERALTE
2 :"<<h2<<" cm\n\n\n";

if(SISMO==1){cout<<"\t\t Zona de
alta actividad Sismica: CRITERIO DE RIGIDEZ \n "<<endl;

}
 else {cout<<"\t\t Zona de regular
actividad Sismica: CRITERIO DE MENOR CUANTIA \n "<<endl;

cout<<"\t\t DIMENSIONES CON

REDONDEO "<<endl;

cout <<"\t\
t___________________________ \n\n";

cout<<"\t\t* BASE de
viga :"<<b_final<<" cm\n";

cout<<"\t\t* PERALTE de
viga :"<<h_final<<" cm\n";

cout <<"\t\t\t\t \n\n";

cout<<"\t\t\t SECCION DE VIGA

"<<endl;

cout << "\t _______

" << endl

<< "\t | |
" << endl

<< "\t |ø ø|
" << endl
 << "\t | |
"<<h_final<<"cm"<<" " << endl

<< "\t | |
" << endl

<< "\t |ø ø|
" << endl

<< "\t |_______|

" << endl

<< "\t
"<<b_final<<"cm"<<" " << endl;

cout
<<"______________________________________________________________________________";

cout <<"\t\t\t \n";

 cout <<"\t\t\t
\n";

cout <<"\n";

cout <<"\t
DESEA CAMBIAR DIMESIONES DE VIGA ? \n\t\t\t" << endl

<<"\t\t\
t1)SI" <<"\t 2)NO \n\t\t\t" << endl;

cout <<"\t\t
DIGITE el NUMERO de opcion :"; cin >>cambio_seccion;

cout <<"\t\t\t
\n";

if
(cambio_seccion==1) goto ETIQUETA_CAMBIO_SEC;

}
 /////////PARAMETRO PERALTE PARAMETRO PERALTE PARAMETRO PERALTE ARAMETRO PERALTE PARAMETRO PERALTE ARAMETRO
PERALTE PARAMETRO PERALTE ARAMETRO PERALTE PARAMETRO PERALTE

else{

system ("CLS");

cout <<"\t\t\t\n";

cout <<"\t\t\t\n\n\n\n\n\n \n";

cout <<"\t\t DIGITE EL PERALTE DE LA SECCION REQUERIDA\n ";

cout <<" \n";

cout <<"\t\t\t h(cm)= "; cin >>h2;

cout <<" \n";

///TIPO DE ZONA SISMICA QUE DESEA UTILIZAR

cout <<"\t\t\t \n";

cout<<"\t\t EN QUE TIPO DE ZONA SISMICA SE UBICA LA ESTRUCTURA?\n";

cout <<"\t\t\t \n";

cout<<"\t\t\t 1) ALTA actividad SISMICA\n";

 cout<<"\t\t\t 2) REGULAR actividad SISMICA\n";

cout <<"\t\t\t \n";

cout <<"\t\t\tDIGITE el NUMERO de opcion :\t"; cin >>SISMO;

if(SISMO==1){///CRITERIO DE RIGIDEZ

b2=b1*pow(h1,3)/pow(h2,3);

else { ///CRITERIO DE CUANTIA

b2=b1*pow(h1,2)/pow(h2,2);

};

system("CLS");

cout <<" \n";

/// se podria agregar una funcion RETURN o GOTO ?? en vez repetir codigo.

/*****************************************************************************************************************/
///REDONDEO DE DIMENSIONES DE VIGA

/*redondea al inmediato superior multiplo de 5*/

///REDONDEO DE BASE DE VIGA

int REDONDEO_BASE,DIVISOR,REDONDEO_PERALTE;

DIVISOR=5; ///buscar el multplo de 5 mas cercano superior

REDONDEO_BASE=ceil(b2); ///redondea al inmediato superior

while(REDONDEO_BASE%DIVISOR != 0) ///*mientras REDONDEO no sea multiplo de DIVISOR, REDONDEO seguira aumentando en 1

REDONDEO_BASE=REDONDEO_BASE+1;

b_final=REDONDEO_BASE; /*asignamos el numero entero multiplo de 5 mas cerca al entero*/

///REDONDEO DE PERALTE DE VIGA

DIVISOR=5;

REDONDEO_PERALTE=ceil(h2);
 while(REDONDEO_PERALTE%DIVISOR != 0)

REDONDEO_PERALTE=REDONDEO_PERALTE+1;

h_final=REDONDEO_PERALTE;

///IMPRESION DE RESULTADOS

system ("CLS"); //limpiar pantalla */

cout<<" ******************************************************************************\n";

cout<<" ******************** RESULTADOS PREDIMESIONADO DE VIGA ***********************\n";

cout<<" ******************************************************************************\n";

cout <<" \n\n";

cout<<"\t\t DIMENSIONES SIN REDONDEO "<<endl;

cout <<"\t\t___________________________ \n\n";

cout<<"\t\t* BASE 0 :"<<b1<<" cm\n";

cout<<"\t\t* PERALTE 0 :"<<h1<<" cm\n\n\n";

cout<<"\t\t* BASE 2 :"<<b2<<" cm\n";

cout<<"\t\t* PERALTE 2 :"<<h2<<" cm\n\n\n";

if(SISMO==1){cout<<"\t\t Zona de alta actividad Sismica: CRITERIO DE RIGIDEZ \n "<<endl;

else {cout<<"\t\t Zona de regular actividad Sismica: CRITERIO DE MENOR CUANTIA \n "<<endl;

cout<<"\t\t DIMENSIONES CON REDONDEO "<<endl;

cout <<"\t\t___________________________ \n\n";

cout<<"\t\t* BASE de viga :"<<b_final<<" cm\n";

cout<<"\t\t* PERALTE de viga :"<<h_final<<" cm\n";

cout <<"\t\t\t\t \n\n";

cout<<"\t\t\t SECCION DE VIGA "<<endl;

cout << "\t _______ " << endl

<< "\t | | " << endl

<< "\t |ø ø| " << endl

<< "\t | | "<<h_final<<"cm"<<" " << endl

 << "\t | | " << endl

<< "\t |ø ø| " << endl

<< "\t |_______| " << endl

<< "\t "<<b_final<<"cm"<<" " << endl;

cout <<"______________________________________________________________________________";

cout <<"\t\t\t \n";

cout <<"\t\t\t \n";

cout <<"\n";

cout <<"\t DESEA CAMBIAR DIMESIONES DE VIGA ? \n\t\t\t" << endl

 <<"\t\t\t1)SI" <<"\t 2)NO \n\t\t\t" << endl;

cout <<"\t\t DIGITE el NUMERO de opcion :"; cin >>cambio_seccion;

cout <<"\t\t\t \n";

if (cambio_seccion==1) goto ETIQUETA_CAMBIO_SEC;

else

cout<<"\n**************** FIN DE DIMENSIONADO DE VIGA *******************\n\t";

cout <<"\t\t \n";

};
 ///VOLVER A DIMENSIONAR OTRA VIGA O SALIR

system("CLS");

cout <<"\t\t\t \n\n";

cout <<"\t\t DESEA DIMENSIONAR OTRA VIGA?\n\t\t\t" << endl

<<"\t\t\t 1)SI, dimensionar nuevamente\n\t\t\t" << endl

<<"\t\t\t 2)Ir al MENU PRINCIPAL\n\t\t\t" << endl;

cout <<"\t\t\t \n";

cout <<"\t\t\t DIGITE el NUMERO de opcion :\t"; cin >>Volver_dimensionar;

cout <<"\t\t\t \n";

}while(Volver_dimensionar!=2);
 }

goto MENU;

break;

///
===============================================================================================================================
============

///================= COLUMNAS =================================================== CLOMUNAS

===================================================

///
===============================================================================================================================
============

case 3:

int Volver_dimensionar_col;

do{

system("CLS");
cout << "*******************************************************************************" << endl

<< "************************* PREDIMENSIONADO DE COlUMNAS *************************" << endl

<< "************************* CONCRETO ARMADO I *************************" << endl

<< "*******************************************************************************" << endl;

cout <<"\n \n";

///DECLARACION DE VARIABLES PRINCIPALES

float PAL,PT,PAC,PVI,PCOL,SC,P_Gravedad_piso,n,P_piso_soporta_col,a,fc,N,AT;

int Tipo_estructura,Tipo_columna;

///TIPO DE USO DE LA EDIFICACION

cout <<"\t AYUDANOS CON LOS SIGUIENTES DATOS\n";

cout <<"\t\t\t \n";

cout <<"\t\t TIPO DE USO DE LA EDIFICACION\n\t\t\t" << endl

<<"\t\t\t 1)vivienda\n\t\t\t" << endl

<<"\t\t\t 2)Oficinas y Departamentos \n\t\t\t" << endl

 <<"\t\t\t 3)Garajes y tiendas \n\t\t\t"<< endl

<<"\t\t\t 4)Depositos A: almacenaje pesado en biblioteca \n\t\t\t" << endl

<<"\t\t\t 5)Depositos B almacenaje pesado en biblioteca \n\t\t\t" << endl;

cout <<"\t\t\t DIGITE el NUMERO de opcion :\t"; cin >>Tipo_estructura;

cout <<"\t\t\t \n";

if (Tipo_estructura!=1 && Tipo_estructura!=2 && Tipo_estructura!=3 && Tipo_estructura!=4 && Tipo_estructura!=5)

cout<<" ERROR: POR FAVOR SELECCIONE UNA DE LAS OPCIONES\n\n";

system("PAUSE");

return 0;

};

switch (Tipo_estructura)

{ case 1:

SC=200;

a=13;

break;

case 2:

SC=250;

a=12;
 break;

case 3:

SC=500;

a=11;

break;

case 4:

SC=750;

a=10;

break;

case 5:

SC=1000;

a=9;

break;

default:

cout<<"ERROR EN LOS DATOS";

break;

}
///CARGAS DE LA ESTRUCTURA

system("CLS");

cout <<"\t\t\t \n";

cout <<"\t\t LAS CARGAS DE LA ESTRUCTURA \n";

cout <<"\t\t\t \n";

cout <<"\t\t DIGITE el PESO de ALIGERADO (kg/m2) = "; cin >>PAL;

cout <<"\n\t\t Digite el PESO de TABIQUERIA (kg/m2)= "; cin >>PT;

cout <<"\n\t\t Digite el PESO de ACABADOS (kg/m2) = "; cin >>PAC;

cout <<"\n\t\t Digite el PESO de VIGAS (kg/m2) = "; cin >>PVI;

cout <<"\n\t\t Digite el PESO de COLUMNAS (kg/m2)= "; cin >>PCOL;

cout <<"\t\t\t \n";

///declara variables a usar

/*otras variables temporales*/

float P_carga_estructura,bd,t;

///SUMATORIA DE CARGAS: CARGA VIVA + CARGA MUERTA en Kg/m2

P_carga_estructura=PAL+PT+PAC+PVI+PCOL+SC;
///AREA TRIBUTARIA

system ("CLS");

cout <<"\t\t\t \n";

cout <<"\t\tAREA TRIBUTARIA\n";

cout <<"\n\t\tDigite el AREA TRIBUTARIA, At(m2) =\t"; cin >>AT;

cout <<"\t\t\t \n";

///NUMERO DE PISOS DE LA ESTRUCTURA

cout <<"\n\t\tNUMERO DE PISOS ? =\t"; cin >>N;

cout <<"\t\t\t \n";

cout <<"\n\t\tRESISTENCIA DEL CONCRETO, fc(kg/cm2)=\t"; cin >>fc;

///PESO POR GRAVEDAD EN UN PISO

P_Gravedad_piso=P_carga_estructura*AT;

///TIPO DE EDIFICACION
system("CLS");

cout <<"\t\t\t \n\n";

cout <<"\t\t TIPO DE COLUMNA DE LA EDIFICACION\n\t\t\t" << endl

<<"\t\t\t 1) Tipo C1-A : para LOS PRIMEROS PISOS (N<3)\n\t\t\t" << endl

<<"\t\t\t 2) Tipo C1-B : para LOS 4 ULTIMOS PISOS(N>4)\n\t\t\t" << endl

<<"\t\t\t 3) Tipo C2 ,tipo C3\n\t\t\t" << endl

<<"\t\t\t 4) Tipo c4\t\t\t" << endl ;

cout <<"\t\t\t \n";

cout <<"\t\t\t DIGITE el NUMERO de opcion :\t"; cin >>Tipo_columna;

cout <<"\t\t\t \n";

if (Tipo_columna!=1 && Tipo_columna!=2 && Tipo_columna!=3 && Tipo_columna!=4)

cout<<" ERROR: POR FAVOR SELECCIONE UNA DE LAS OPCIONES\n\n";

system("PAUSE");

return 0;

};

if (Tipo_columna>0) {

switch(Tipo_columna)

{
case 1:

n=0.30;

P_piso_soporta_col=1.10*P_Gravedad_piso;

break;

case 2:

n=0.25;

P_piso_soporta_col=1.10*P_Gravedad_piso;

break;

case 3:

n=0.25;

P_piso_soporta_col=1.25*P_Gravedad_piso;

break;

case 4:

n=0.20;

P_piso_soporta_col=1.50*P_Gravedad_piso;

break;

default:

cout<<"ERROR EN LOS DATOS";

 break;

};

bd=(P_piso_soporta_col/(n*fc)*N);

t=sqrt(P_piso_soporta_col/(n*fc)*N);

///*redondeo seccion de columna*///

int REDONDEO,DIVISOR;

DIVISOR=5; /*buscar el multplo de 5 mas cercano superior*/

REDONDEO=ceil(t); /*redondea al inmesiato superior*/;

/*mientras RE no sea multiplo de BB, RE seguira aumentando en 1*/

while(REDONDEO%DIVISOR != 0)

REDONDEO=REDONDEO+1;
 }

t=REDONDEO; /*asignamos el numero entero multiplo de 5 mas cerca al entero*/

cout <<"\t\t\t \n";

cout<<"\t************ FIN DE INGRESO DE DATOS***************\n\t";

cout <<"\t\t\t \n";

system("PAUSE");

system ("CLS"); //limpiar pantalla */

cout <<"\t\t\t \n";

cout<<"***************** RESULTADOS PREDIMESIONADO DE COLUMNA ***************\n\t";

cout <<"\t\t\t \n\t";

cout<<"© CARGA por kg/m2 :"<<P_carga_estructura<<" kg/m2\n\t";

cout<<"© PESO por PISO :"<<P_Gravedad_piso<<" kg\n\t";

cout<<"© PESO TOTAL ESTRUCTURA :"<<P_Gravedad_piso*10<<" kg\n\t";

cout<<"© Dimensionamiento de columna bd=:"<<bd<<" cm2\n\t";

cout<<"© SECCION CUADRADA, b=d=t :"<<t/100<<"*"<<t/100<<" m2\n";

cout <<"\t\t\t \n";

 cout << "\t\t "<<t/100<<"m"<<" " << endl;

cout << "\t\t ____________ " << endl

<< "\t\t /:::::::::::/| " << endl

<< "\t\t /:::::::::::/"<<t/100<<"m"<<" " << endl

<< "\t\t /:::::::::::/ | " << endl

<< "\t\t *-----------* | " << endl

<< "\t\t | | | " << endl

<< "\t\t | | | " << endl

<< "\t\t | | | " << endl

<< "\t\t | | | " << endl

<< "\t\t | | | " << endl

<< "\t\t | | | " << endl

<< "\t\t | | | " << endl

<< "\t\t | | | " << endl

<< "\t\t | | / " << endl

<< "\t\t | |/ " << endl

<< "\t\t |___________|/ " << endl;

getch();
 system("PAUSE");

///VOLVER A DIMENSIONAR OTRA COLUMNA O SALIR

system("CLS");

cout <<"\t\t\t \n\n";

cout <<"\t\t DESEA DIMENSIOANAR OTRA COMLUMNA ?\n\t\t\t" << endl

<<"\t\t\t 1)SI, dimensionar nuevamente\n\t\t\t" << endl

<<"\t\t\t 2)SALIR\n\t\t\t" << endl;

cout <<"\t\t\t \n";

cout <<"\t\t\t DIGITE el NUMERO de opcion :\t"; cin >>Volver_dimensionar_col;

cout <<"\t\t\t \n";

}while(Volver_dimensionar_col!=2);
 }

goto MENU;

break;

///
===============================================================================================================================
============

///================= PLACAS ======================================================= PLACAS

===================================================

///
===============================================================================================================================
============

case 4:

int Volver_dimensionar_placa;

do{

system("CLS");
cout << "*******************************************************************************" << endl

<< "******************** PREDIMENSIONADO DE PLACAS ***********************" << endl

<< "********************* CONCRETO ARMADO I ***********************" << endl

<< "*******************************************************************************" << endl;

cout <<"\n \n";

float H,A,espesor_placa,B,cociente,residuo;

do{

cout <<"\t\t\t DIGITE LA ALTURA\n\t\t\t H(metros)=";

cin >>H;

cout <<"\t\t\t \n";

A=H-4.5;

system("CLS");

if(A<0) cout<<"\t\t\tNo se puede continuar\n\t\t\tDIGITE UNA ALTURA MAYOR\n\n\n ";

 cout <<"\t\t\t \n";

}while(A<0);

/*realizamos el siguiente artificio para cumplir con la norma ACI-305*/

/*espesor de losas en los ultimos 4 pisos =15cm y 2.5cm mas por cada 7.5m de altura*/

/*ademas por cada fracion se aumentar en 2.5cm al espesor*/

B=7.5;

///ADICIONA 2.5CM CADA 7.5 Y TAMBIEN POR FRACCION

//RESTA SUCECIVA

cociente=0;

while (A>=B) {

A=A-B;

cociente=cociente+1;

};

residuo=A;

/* al cociente de la division le aumentamos en 1, y luego multiplicamos por 2.5 */

/*esto se adecua a la norma, comentada anteriormente*/

if(residuo==0) {

espesor_placa=15+(cociente)*2.5 ;

else {

espesor_placa=15+(cociente+1)*2.5;

};

///*REDONDEO DE ESPESOR DE PLACA

int REDONDEO;

REDONDEO=ceil(espesor_placa); /*redondea al inmesiato superior*/;

system("CLS");

cout<<"\n***************** RESULTADOS PREDIMESIONADO PLACA ****************************\n\t";

cout <<"\t\t\t \n";

cout <<"\t\t -> Altura de PLACA : "<<H<<" "<<"metros";cout <<"\t\t\t \n";

cout <<"\t\t\t \n";

cout<<"\t\t * ESPESOR DE PLACA : "<<espesor_placa<<" "<<"centimetros";cout <<"\t\t\t \n";

cout<<"\t\t * ESPESOR DE PLACA - redondeado : "<<REDONDEO<<" "<<"centimetros";

cout <<"\t\t\t \n";

cout <<"\t\t\t \n";

/*deja un espacion*/

cout<<"\t\t \n";

cout<<"****************************************************************************\n";

///VOLVER A DIMENSIONAR OTRA PLACA

cout <<"\t\t\t \n\n";

cout <<"\t\t DESEA DIMENSIOANAR OTRA PLACA ?\n\t\t\t" << endl

<<"\t\t\t 1)SI, dimensionar nuevamente\n\t\t\t" << endl

<<"\t\t\t 2)Ir al MENU PRINCIPAL\n\t\t\t" << endl;

cout <<"\t\t\t \n";

cout <<"\t\t\t DIGITE el NUMERO de opcion :\t"; cin >>Volver_dimensionar_placa;

cout <<"\t\t\t \n";

 }while(Volver_dimensionar_placa!=2);

goto MENU;

default:

break;

}
}while(elemento_estructural==5);