Proyecto de Programación DISEÑO DE MEZCLA - Paucara Coaguila Yean Martin

UNIVERSIDAD RICARDO PALMA
ESCUELA PROFESIONAL DE INGENIERÍA CIVIL

FACULTAD DE INGENIERÍA
TITULO: Diseño de mezclas de Hormigón (Concreto)
PROYECTO DE PROGRAMACIÓN PRESENTADO POR

Paucara Coaguila Yean Martin
201220784
LIMA - PERÚ
2015 - II
INDICE
I. PLANTEAMIENT DEL PROBLEMA ................................................................ 3

1.2 Formulación y delimitación del problema ......................................................... 4
1.2.1 Problema general .................................................................................... 4
1.2.2 Problemas específicos ............................................................................. 4
1.3 Importancia del proyecto .................................................................................... 5
II. OBJETIVOS ............................................................................................................ 5
2.1. Objetivo general: ................................................................................................ 5
2.2 Objetivos específicos: ........................................................................................ 5
III. MARCO TEORICO................................................................................................ 5
3.1 Estructura teórica ............................................................................................... 6
3.2 Definición de términos básicos .......................................................................... 6
IV. HIPÓTESIS ............................................................................................................. 8
4.1 Hipótesis General ................................................................................................ 8
4.2 Hipótesis Específica ............................................................................................ 8
V. DESARROLLO DEL PROGRAMA ....................................................................... 9
6.1. Enunciado resumen del caso a desarrollar ......................................................... 9
6.2. Definición de variables a utilizar ....................................................................... 9
6.3. Definición de variables de entrada y Salida ..................................................... 10
6.4. Definición de los tipos de datos a emplear ...................................................... 10
6.5. Desarrollo del Algoritmo (Diagrama de Flujo) ............................................... 10
6.6. Codificación del Programa .............................................................................. 11
6.7. Pruebas del programa ....................................................................................... 30
6.7.1. Resolución manual del caso .................................................................. 30
6.7.2. Resolución usando el software desarrollado (Captura de Pantallas) .... 30
VII. REFERENCIAS BIBLIOGRÁFICAS Y ANEXOS ......... Error! Bookmark not
defined.
-2-
I. PLANTEAMIENT DEL PROBLEMA
1.1 Planteamiento del problema:

Actualmente, el concreto es el elemento más usado en el ámbito mundial para la
construcción, lo que conlleva a la evolución de las exigencias para cada uso del
hormigón (concreto).
La demanda del concreto ha sido la base para la elaboración de los diferentes
Diseños de Mezcla, ya que estos métodos permiten a los usuarios conocer no
sólo las dosis precisas de los componentes del concreto, sino también la forma
más apropiada para elaborar la mezcla.. Los Métodos de Diseño de mezcla están
dirigidos a mejorar calificativamente la resistencia, la calidad y la durabilidad de
todos los usos que pueda tener el concreto.
Diseño de Mezcla
Es un proceso que consiste en calcular las proporciones de los elementos que
forman el concreto, con el fin de obtener los mejores resultados.
Existen diferentes métodos de Diseños de Mezcla; algunos pueden ser muy
complejos como consecuencia a la existencia de múltiples variables de las que
dependen los resultados de dichos métodos, aun así, se desconoce el método que
ofrezca resultados perfectos, sin embargo, existe la posibilidad de seleccionar
alguno según sea la ocasión.
En oportunidades no es necesario tener exactitud en cuanto a las proporciones de
los componentes del concreto, en estas situaciones se frecuenta el uso de reglas
generales, lo que permite establecer las dosis correctas a través de métodos que
permiten contar con un diseño de mezcla apropiado para estos casos.
Materiales que intervienen en una mezcla de concreto son el cemento, agua,

agregado (fino y grueso), aire y aditivos, con las cuales se pretende hallar la
proporciones necesarias para de cada una de estas para obtener buenos
resultados en el concreto a utilizar.
En la actualidad existen 3 métodos utilizados con mayor frecuencia y veracidad,
las cuales son;
-El método del ACI
-3-
-El método del módulo de finura de combinación de agregados.
-El método de la Curva de Fuller .
Al diseñar una mezcla de concreto y/o en la búsqueda de las proporciones en

peso y volumen para un trabajo específico, se requieres de cálculos matemáticos,
tablas, granulometrías y descripciones del trabajo a realizar ya sea la zona donde
se va ejecutar y la calidad del concreto, por ello antes de aplicar los métodos se
necesita saber con exactitud todas las características de los materiales y eso
conlleva a trabajos extensos y repetitivos de cálculos, etc.
El problema radica como así mismo se explica, que hay cálculos repetitivos o
cálculos donde solo se cambia una variable, ya sea por la búsqueda de lo que se
pide o la de mejorar la calidad del concreto, la utilización de tiempo (perdida),
dinero para pagar a personas calificadas para estos cálculos, etc.
Se entiende que este trabajo es solo para hallar las proporciones de los materiales
en una obra y por ello la no preocupación del algunas empresas o personas
dedicas a este rubro por buscar una solución rápida, o un programa en general
que se encargue de la ejecución de estos métodos para así poder probar,
experimentar con varias proporciones para así llegar a un mejor acabado y poder
descartar la posibles fallas en estas.
Una de las soluciones más factible es la creación de un programa en C# ,que
pida los datos y características generales y nos dé como respuesta la
proporciones en peso y volumen ,así evitándonos los cálculos y el tiempo de
demora al realizar estos .
1.2 Formulación y delimitación del problema
1.2.1 Problema general:

Como se mejora el diseño de las mezclas utilizando la programación en
C#.
1.2.2 Problemas específicos:
-4-
Como se mejora el cálculo de las proporciones de los elementos
utilizados en obra utilizando la programación c#.
Como optimizamos el uso de los estándares en el diseño de diseño de

mezclas utilizando la programación c#.
1.3 Importancia del proyecto:

Este proyecto como tal lo muestra, es de vital importancia para los cálculos
matemáticos directos para hallar las cantidades de materiales para una obra o
trabajo y así ahorrarse el tiempo del calculista y/o el tiempo del encargado
de obra.
II. OBJETIVOS
2.1. Objetivo general:

Desarrollar un programa en c# para mejorar el diseño de las mezclas de concreto
armado.
Determinar la cantidad de materiales para la elaboración del diseño de mezcla de

un concreto que satisfaga los requerimientos de uso teniendo en cuenta
economía y que cumpla con las especificaciones exigidas en determinada obra.
2.2 Objetivos específicos:

Desarrollar un programa para mejorar los cálculos de la proporciones.
Optimizar el uso de los estándares en el diseño de diseño de mezclas utilizando
la programación c#.
III. MARCO TEORICO
-5-
3.1 Estructura teórica
Mezcla de Hormigón (concreto)
El concreto es la mezcla del cemento, agregados inertes (arena y grava) y

agua, la cual se endurece después de cierto tiempo formando una piedra
artificial. Los elementos activos del concreto son el agua y el cemento de
los cuales ocurre una reacción química que después de fraguar alcanza
un estado de gran solidez , y los elementos inerte , que son la arena y la
grava cuya función es formar el esqueleto de la mezcla , ocupando un
gran porcentaje del volumen final del producto .
3.2 Definición de términos básicos
Cemento:
El cemento es un conglomerante formado a partir de unas mezclas de caliza y

arcilla calcinadas y posteriormente molidas, que tiene la propiedad de
endurecerse al contacto con el agua. Hasta este punto la molienda entre estas
rocas es llamada Clinker, esta se convierte en cemento cuando se le agrega yeso,
este le da la propiedad a esta mezcla para que pueda fraguar y endurecerse.
Arena (hormigón):
El árido fino o arena constituye de hecho la mayor parte del porcentaje en peso
del hormigón. Dicho porcentaje usualmente supera el 60 % del peso en el
hormigón fraguado y endurecido. La adecuación de un árido para la fabricación
de hormigón debe cumplir un conjunto de requisitos usualmente recogidos en las
normas como la EHE, el euro código 2 o las normas ASCE/SEI. Dichos
requisitos se refieren normalmente a la composición química, la granulometría,
los coeficientes de forma y el tamaño.
Agua:
El agua, considerada como materia prima para la confección y el curado del

hormigón debe cumplir con determinadas normas de calidad. Las normas para la
-6-
calidad del agua son variables de país a país, y también pueden tener alguna
variación según el tipo de cemento que se quiera mezclar. Las normas que se
detallan a continuación son por lo tanto generales. Esta deberá ser limpia y
fresca hasta donde sea posible y no deberá contener residuos de aceites, ácidos,
sulfatos de magnesio, sodio y calcio (llamados álcalis blandos) sales, limo,
materias orgánicas u otras sustancias dañinas y estará asimismo exenta de
arcilla, lodo y algas.
Aditivos:
Los aditivos para hormigón (concreto) son componentes de naturaleza orgánica

(resinas) o inorgánica, cuya inclusión tiene como objeto modificar las
propiedades físicas de los materiales conglomerados en estado fresco. Se suelen
presentar en forma de polvo o de líquido, como emulsiones.
ACI: Instituto Americano del Concreto
-7-
IV. HIPÓTESIS
4.1 Hipótesis General:

Con el desarrollo de un programa en c# mejoraríamos el diseño de las mezclas
de concreto armado.
4.2 Hipótesis Específica:
Desarrollando un programa en mejoraríamos las proporciones en obra y así

mismo podríamos mejorar la calidad de nuestro trabajo.
Optimizando el uso de los estándares en el diseño de diseño de mezclas

tendríamos un mejor resultado al ejecutar la calidad de nuestro concreto.
-8-
V. DESARROLLO DEL PROGRAMA
6.1. Enunciado resumen del caso a desarrollar:
EL método del ACI y método de combinación de agregado son usados con

mayor preferencia ya que su rango de error es casi nula, y se usa casi
siempre para las pruebas de probetas antes y después de un obra y/o trabajo
con concreto armado, las demora y el tiempo utilizado para realizar estas lo
hace un poco complicado más allá del tiempo empleado para rehacer los
cálculos si se falla.
Sin embargo con este proyecto se busca una manera rápida y concreta de
poder realizar estos cálculos, solo ingresar los datos principales y con la
capacidad de poder corregirlos a la medida que sea necesaria.
6.2. Definición de nombres de variables a utilizar:
s=Desviación estándar,
Sul=Sulfatos en ppm,
Tc=Tipo de cemento,
t,c,g,w,ñ,m=Variable de carácter,
Tmn=Tamaño máximo nominal.
Fc=Factor cemento,
aui=cemento,
pe=Peso especifico,
mf=Modulo de finesa,
mg=Modulo de finesa del agregado grueso,
bbo=Cantidad de agregado grueso,
pucs=Peso unitario compactado seco,
pedmg=Peso específico de la masa ,
volaf=Volumen del agregado fino,
pedmf=Peso especifico de la masa,
pdfa=Peso del agregado fino,
chf=Contenido de humedad del fino,
-9-
chg=Contenido de humedad del grueso,
pussf=Peso unitario suelto seco del fino,
6.3. Definición de variables de entrada y Salida
ENTRADA=
s=Desviación estándar,
Sul=Sulfatos en ppm,
Tc=Tipo de cemento,
t,c,g,w,ñ,m=Variable de carácter,
Tmn=Tamaño máximo nominal.
SALIDA=
aui=cemento,
Volabf=Volumen absoluto del fino
Volabf=Volumen absoluto del grueso
6.4. Definición de los tipos de datos a emplear
int= Entero que almacena datos (-2.147.483.648 a 2.147.483.647).

Double=Almacena valores de punto flotante de 64bits.
String=Representa texto como una serie de variables.
Char=Para declarar una instancia de la estructura.
6.5. Desarrollo del Algoritmo (Diagrama de Flujo)
- 10 -
6.6. Codificación del Programa:
{
class Program
{
static void Main(string[] args)
{
int S, Sul, Tc;
char t, c, g, w, ñ, m;
double Tmn, Fc, aire = 0, ac = 0, menor = 100000, aui, Fcra, Fcrb, Fcrc = 0, acem = 0, aguc = 0, pe = 0, fcv = 0, mf, mg, bbo =
0, pucsg, pdag, pedmg = 0,
volaf = 0, pedmf = 0, pdaf = 0,
chf, chg, qwe, qwr, pabf, pabg, qwt, pussf, pussg, pol, pal, pes, cemento, agrueso,
adm = 0, sape, sapo, pc, pf, pg, pa, vc, vf, vg, va, mfin = 0, zf, zg, rf, rg, volab, volabf, volabg,
paf, pag, rosa, evelyn, val, benel, invo, pro, gra, ma, cion, di, gi, tal, sipi;
string oo;
Console.WriteLine("===============BIENVENIDO ===============");
Console.WriteLine("______________DISEÑO DE MEZCLAS DE HORMIGÓN (CONCRETO)_________________");
Console.WriteLine("");
Console.WriteLine("==========================================================================================
======");
Console.WriteLine("**Cálculo de proporciones en peso y volumenen en obra por metro cubico,aplicando los métodos del
ACI y Módulo de Fineza de la combinación de agregados**");
Console.WriteLine("CALCULO DE LA RESISTENCIA PROMEDIO");
Console.Write("Ingrese la resistencia en compresión promedio=");
Fc = double.Parse(Console.ReadLine());
Console.Write("Este proyecto cuenta con desviación estandar?(Si='s')(No='Cualquier caracter')=");
t = char.Parse(Console.ReadLine());
if (t == 's' || t == 'S')
{
Console.Write("Ingrese La Desviación estandar=");
S = int.Parse(Console.ReadLine());
Fcra = Fc + (1.34) * (S);
Fcrb = Fc + (2.33) * (S) - 35;
if (Fcra > Fcrc)
{
Fcrc = Fcra;
}
if (Fcrb > Fcrc)
{
Fcrc = Fcrb;
}
Fcrc = Math.Ceiling(Fcrc);
Console.WriteLine("El valor de F'Cr=" + Fcrc + "Kg/cm2");
}
else
{
if (Fc <= 210)
Fcrc = Fc + 70;
if (Fc > 210 || Fc < 350)
Fcrc = Fc + 84;
if (Fc > 350)
Fcrc = Fc + 98;
Console.WriteLine("El valor de F'cr=" + Fcrc + "Kg/cm2");

}
- 11 -
Console.WriteLine("============================================================== ");
Console.WriteLine("CONSISTENCIA DE LA MEZCLA");
Console.WriteLine("Asentamiento Seco(2.5 a 5.0)");
Console.WriteLine("Asentamiento Plastico (7.5 a 10.0)");
Console.WriteLine("Asentamiento Fluido(15.0 a 17.5)");
asentamiento:
sapee:
Console.Write("Ingrese la consitencia(S=Seco),(P=Plastico),(F=Fluido)=");
c = char.Parse(Console.ReadLine());
if (c == 's' || c == 'S' || c == 'P' || c == 'p' || c == 'F' || c == 'f')
{
Console.WriteLine("==================================================================");
Console.WriteLine("TAMAÑO MÁXIMOS NOMINALES DE AGREGADO GRUESO:");
Console.WriteLine("'9.5mm-(3/8pulg)'");
Console.WriteLine("'25.4mm-(1pulg)'");
Console.WriteLine("'38.0mm-(1 1/2pulg)'");
Console.WriteLine("'50.8mm-(2 pulg)'");
Console.WriteLine("'76.0mm-(3pulg)'");
Console.WriteLine("'152.0-(6pulg)'");
Console.Write("Ingrese el Numero del Tamiz del tamaño maximo Nominal del agregado en Milimetros(mm)(1 decimal
porfavor como se muestra en pantalla)=");
Tmn = Double.Parse(Console.ReadLine());
Tmn = Math.Round(Tmn, 1);
Console.WriteLine("Costa=Sin aire incorporado");
Console.WriteLine("sierra y selva=Con aire incorporado");
Console.Write("Este proyecto se realizará en la Costa('A'),Sierra('B')o Selva('C')=");
g = Char.Parse(Console.ReadLine());
if (g == 'a' || g == 'A')
{
if (c == 's' || c == 'S')
{
if (Tmn == 9.5)
{
adm = 205;
aire = 3.0;
Console.WriteLine("El agua de mezclado es =" + adm);
Console.WriteLine("El contenido de aire a usar es =" + aire);
}
if (Tmn == 12.7)
{
adm = 200;
aire = 2.5;
}
if (Tmn == 19.0)
{
adm = 185;
aire = 2.0;
}
if (Tmn == 25.4)
{
adm = 180;
aire = 1.5;
- 12 -
}
if (Tmn == 38.0)
{
adm = 160;
aire = 1.0;
}
if (Tmn == 50.8)
{
adm = 155;
aire = 0.5;
}
if (Tmn == 76.0)
{
adm = 145;
aire = 0.3;
}
if (Tmn == 152.0)
{
adm = 125;
aire = 0.2;
}
}
if (c == 'p' || c == 'P')
{
if (Tmn == 9.5)
{
adm = 225;
aire = 3.0;
}
if (Tmn == 12.7)
{
adm = 215;
aire = 2.5;
}
if (Tmn == 19.0)
{
adm = 200;
aire = 2.0;
}
if (Tmn == 25.4)
{
adm = 195;
aire = 1.5;
}
if (Tmn == 38.0)
{
adm = 175;
aire = 1.0;
}
if (Tmn == 50.8)
{
- 13 -
adm = 170;
aire = 0.5;
}
if (Tmn == 76.0)
{
adm = 160;
aire = 0.3;
}
if (Tmn == 152.0)
{
adm = 140;
aire = 0.2;
}
}
if (c == 'f' || c == 'F')
{
if (Tmn == 9.5)
{
adm = 240;
aire = 3.0;
}
if (Tmn == 12.7)
{
adm = 230;
aire = 2.5;
}
if (Tmn == 19.0)
{
adm = 210;
aire = 2.0;
}
if (Tmn == 25.4)
{
adm = 205;
aire = 1.5;
}
if (Tmn == 38.0)
{
adm = 185;
aire = 1.0;
}
if (Tmn == 50.8)
{
adm = 180;
aire = 0.5;
}
if (Tmn == 76.0)
{
adm = 170;
aire = 0.3;
}
- 14 -
if (Tmn == 152.0)
{
adm = 165;
aire = 0.2;
}
}
}
if (g == 'b' || g == 'B' || g == 'c' || g == 'C')
{
if (c == 's' || c == 'S')
{
if (Tmn == 9.5)
{
adm = 180;
aire = 8.0;
}
if (Tmn == 12.7)
{
adm = 175;
aire = 7.0;
}
if (Tmn == 19.0)
{
adm = 165;
aire = 6.0;
}
if (Tmn == 25.4)
{
adm = 160;
aire = 5.0;
}
if (Tmn == 38.0)
{
adm = 145;
aire = 4.5;
}
if (Tmn == 50.8)
{
adm = 140;
aire = 4.0;
}
if (Tmn == 76.0)
{
adm = 135;
aire = 3.5;
}
if (Tmn == 152.0)
{
adm = 120;
aire = 3.0;
}
- 15 -
}
if (c == 'p' || c == 'P')
{
if (Tmn == 9.5)
{
adm = 200;
aire = 8.0;
}
if (Tmn == 12.7)
{
adm = 190;
aire = 7.0;
}
if (Tmn == 19.0)
{
adm = 180;
aire = 6.0;
}
if (Tmn == 25.4)
{
adm = 175;
aire = 5.0;
}
if (Tmn == 38.0)
{
adm = 160;
aire = 4.5;
}
if (Tmn == 50.8)
{
adm = 155;
aire = 4.0;
}
if (Tmn == 76.0)
{
adm = 150;
aire = 3.5;
}
if (Tmn == 152.0)
{
adm = 135;
aire = 3.0;
}
}
if (c == 'f' || c == 'F')
{
if (Tmn == 9.5)
{
adm = 215;
aire = 8.0;
}
if (Tmn == 12.7)
- 16 -
{
adm = 205;
aire = 7.0;
}
if (Tmn == 19.0)
{
adm = 190;
aire = 6.0;
}
if (Tmn == 25.4)
{
adm = 185;
aire = 5.0;
}
if (Tmn == 38.0)
{
adm = 170;
aire = 4.5;
}
if (Tmn == 50.8)
{
adm = 165;
aire = 4.0;
}
if (Tmn == 76.0)
{
adm = 160;
aire = 3.5;
}
if (Tmn == 152.0)
{
adm = 155;
aire = 3.0;
}
}
else
{
Console.WriteLine("No especifico bien la consistencia,Porfavor ingrese denuevo:");
goto asentamiento;
}
Console.WriteLine("===================================");
Console.WriteLine("Relacion agua/cemento de diseño");
Console.WriteLine("Por Resitencia");
Console.WriteLine("*****F'cr=" + Fcrc);
if (g == 'a' || g == 'A')
{
if (Fcrc == 450)
acem = 0.38;
if (Fcrc == 400)
acem = 0.43;
- 17 -
if (Fcrc == 350)
acem = 0.48;
if (Fcrc == 300)
acem = 0.55;
if (Fcrc == 250)
acem = 0.62;
if (Fcrc == 200)
ac = 0.70;
if (Fcrc == 150)
acem = 0.80;
if (Fcrc < 450 && Fcrc > 400)
ac = (0.38 * (Fcrc - 400) + 0.43 * (450 - Fcrc)) / 50.0;
acem = Math.Round(ac, 3);
if (Fcrc < 400 && Fcrc > 350)
ac = (0.43 * (Fcrc - 350) + 0.48 * (400 - Fcrc)) / 50.0;
if (Fcrc < 350 && Fcrc > 300)
ac = (0.48 * (Fcrc - 300) + 0.55 * (350 - Fcrc)) / 50.0;
if (Fcrc < 300 && Fcrc > 250)
ac = (0.55 * (Fcrc - 250) + 0.62 * (300 - Fcrc)) / 50.0;
if (Fcrc < 250 && Fcrc > 200)
ac = (0.62 * (Fcrc - 200) + 0.70 * (250 - Fcrc)) / 50.0;
if (Fcrc < 200 && Fcrc > 150)
ac = (0.70 * (Fcrc - 150) + 0.80 * (200 - Fcrc)) / 50.0;
Console.WriteLine("La Relacion agua/cemento (a/c)=" + acem);
}
if (g == 'b' || g == 'B' || g == 'c' || g == 'C')
{
if (Fcrc == 450)
{
Console.WriteLine("Para la resistencia de 450Kg/cm2 con aire incorporado no se especifica una relacion porfavor elejir
la opcion sin aire incorporado");
goto sapee;
}
if (Fcrc == 400)
{
goto sapee;
}
if (Fcrc == 350)
acem = 0.40;
if (Fcrc == 300)
acem = 0.46;
if (Fcrc == 250)
acem = 0.53;
if (Fcrc == 200)
ac = 0.61;
if (Fcrc == 150)
acem = 0.71;
if (Fcrc < 450 && Fcrc > 400)
{
Console.WriteLine("Para la resistencia obtenida con aire incorporado no se especifica una relacion porfavor elejir la
opcion sin aire incorporado");
goto sapee;
}
if (Fcrc > 350)
{
goto sapee;
}
if (Fcrc < 350 && Fcrc > 300)
{
- 18 -
ac = (0.40 * (Fcrc - 300) + 0.46 * (350 - Fcrc)) / 50.0;
}
if (Fcrc < 300 && Fcrc > 250)
{
ac = (0.46 * (Fcrc - 250) + 0.53 * (300 - Fcrc)) / 50.0;
}
if (Fcrc < 250 && Fcrc > 200)
{
ac = (0.53 * (Fcrc - 200) + 0.61 * (250 - Fcrc)) / 50.0;
}
if (Fcrc < 200 && Fcrc > 150)
{
ac = (0.61 * (Fcrc - 150) + 0.71 * (200 - Fcrc)) / 50.0;
}
Console.WriteLine("La Relacion agua/cemento (a/c)=" + acem);
}
Console.WriteLine("=========================");
Console.WriteLine("Por Durabilidad");
porfavor:
Console.Write("El Cemento estará expuesto a sulfatos?(Si='s'),(No='n').=");
w = char.Parse(Console.ReadLine());
if (w == 's' || w == 'S')
{
Console.Write("Ingrese el sulfato en agua en pmm=");
Sul = int.Parse(Console.ReadLine());
if (Sul > 0 && Sul < 150)
{
oo = "Tipo I";
aguc = +acem;
Console.WriteLine("Tipo de cemento a usar=" + oo);
Console.WriteLine("La Relacion agua/cemento (a/c)=" + aguc);
}
if (Sul > 150 && Sul < 1500)
{
oo = "Tipo II";
aguc = 0.50;
}
if (Sul > 1500)
{
oo = "Tipo V";
aguc = 0.45;
}
}
else if(w == 'n' || w == 'N')
{
Console.WriteLine("El tipo de cemento a usar es El tipo I");
Console.WriteLine("La relacion agua/cemento es:"+acem);
}
else
{
Console.Write("ingrese bien las variables porfavor");
goto porfavor;
}
- 19 -
Console.Write("¿Desea usted que el programa elija el tipo de cemento segun las normas?(Si='s'),(No='n')=");
ñ = Char.Parse(Console.ReadLine());
if (ñ == 's' || ñ == 's')
{
oo = "tipo I";
Console.WriteLine("Marcas de cemento:");
Console.WriteLine("======================");
Console.WriteLine("Marca " + "\t\t" + "Tipo");
Console.WriteLine("______________________");
Console.WriteLine("Lima(L)" + "\t\t" + "3.13");
Console.WriteLine("Pacasmayo(P)" + "\t" + "3.15");
Console.WriteLine("Yura(Y)" + "\t\t" + "3.00");
Console.WriteLine("Andino(A)" + "\t\t" + "3.11");
Console.Write("Ingrese la marca de cemento que desea usar=");
m = Char.Parse(Console.ReadLine());
if (m=='l'||m=='L')
{
oo = "Lima";
pe = 3.13;
Console.WriteLine("Marca de cemento es =" + oo);
Console.WriteLine("El peso especifico a usar es =" + pe);
}
if (m == 'p' || m == 'P')
{
oo = "Pacasmayo";
pe = 3.15;
}
if (m == 'y' || m == 'Y')
{
oo = "Yura";
pe = 3.00;
}
if (m == 'a' || m == 'A')
{
oo = "Andino";
pe = 3.11;
}
}
else if (ñ == 'n' || ñ == 'N')
{
variables:
Console.WriteLine("Se muestra la tabla completa de marcas y tipos de cementos mas usados y/o para este proyecto(si
desea agregar o modificar los pesos especificos comunicarse al numero 945091661)");
Console.WriteLine("Marca " + "\t\t" + "Tipo 1" + "\t" + "Tipo 2" + "\t" + "Tipo 5");
Console.WriteLine("________________________________________");
Console.WriteLine("Lima(L)" + "\t\t" + "3.13" + "\t" + "3.12" + "\t" + "3.11");
Console.WriteLine("Pacasmayo(P)" + "\t" + "3.15" + "\t" + "3.10" + "\t" + "3.13");
Console.WriteLine("Yura(Y)" + "\t\t" + "3.00" + "\t" + "3.11" + "\t" + "3.12");
Console.WriteLine("Andino(A)" + "\t" + "3.11" + "\t" + "3.10" + "\t" + "3.18");
Console.Write("Elija la marca de cemento=");
m = char.Parse(Console.ReadLine());
- 20 -
tipocem:
Console.Write("Elija el tipo de cemento a usar (1,2,5)=");
Tc = int.Parse(Console.ReadLine());
if (m == 'l' || m == 'L')
{
if (Tc == 1)
{
pe = 3.13;
Console.WriteLine("peso especifico=" + pe);
}
else if (Tc == 2)
{
pe = 3.12;
}
else if (Tc == 5)
{
pe = 3.11;
}
else
{
Console.WriteLine("Ingresa bien los datos porfavor");
goto tipocem;
}
}
else if (m == 'p' || m == 'P')
{
if (Tc == 1)
{
pe = 3.15;
}
else if (Tc == 2)
{
pe = 3.10;
}
else if (Tc == 5)
{
pe = 3.13;
}
else
{
goto tipocem;
}
}
else if (m == 'y' || m == 'Y')
{
if (Tc == 1)
{
pe = 3.00;
}
else if (Tc == 2)
{
pe = 3.11;
}
else if (Tc == 5)
{
pe = 3.18;
}
else
{
- 21 -
goto tipocem;
}
}
else if (m == 'a' || m == 'A')
{
if (Tc == 1)
{
pe = 3.11;
}
else if (Tc == 2)
{
pe = 3.10;
}
else if (Tc == 5)
{
pe = 3.18;
}
else
{
goto tipocem;
}
}
else
{
Console.WriteLine("ingrese una de las variables del cemento porfavor");
goto variables;
}
}
else
{
Console.WriteLine("Ingrese una de la variables 's' o ' n' porfavor:");
goto porfavor;
if (acem < menor)

{
menor = acem;
}
else if (aguc < menor)
{
menor = aguc;
}
Console.WriteLine("======================================================================");
Console.WriteLine("========================================");
Console.WriteLine("La relación agua/cemento(a/c)=" + menor);
Console.WriteLine("==================");
Console.WriteLine("Contenido de cemento");
fcv = +adm / menor;

aui = fcv / 42.5;
Console.WriteLine("El factor cemento (F.C)=" + Math.Round(fcv,2));

Console.WriteLine("El Factor cemento en bolsas es =" + Math.Round(aui,2));
- 22 -
Console.WriteLine("==========================================================================================
=====");
Console.WriteLine("METODO DEL ACI");
Console.WriteLine("Ingresar el modulo de finura porfavor=");
mf = double.Parse(Console.ReadLine());
Console.WriteLine("Cantidad de agregado grueso b/b0)");
if (Tmn == 9.5)
{
if (mf == 2.40)
bbo = 0.50;
if (mf == 2.60)
bbo = 0.48;
if (mf == 2.80)
bbo = 0.46;
if (mf == 3.00)
bbo = 0.44;
if (mf > 2.40 || mf < 2.60)
bbo = (0.50 * (mf - 2.60) + 0.48 * (2.40 - mf)) / -0.2;
if (mf > 2.60 || mf < 2.80)
bbo = (0.48 * (mf - 2.80) + 0.46 * (2.60 - mf) )/ -0.2;
if (mf > 2.80 || mf < 3.00)
bbo = (0.46 * (mf - 3.00) + 0.44 * (2.80 - mf)) / -0.2;
}
if (Tmn == 12.7)
{
if (mf == 2.40)
bbo = 0.59;
if (mf == 2.60)
bbo = 0.57;
if (mf == 2.80)
bbo = 0.55;
if (mf == 3.00)
bbo = 0.53;
if (mf > 2.40 || mf < 2.60)
bbo = (0.59 * (mf - 2.60) + 0.57 * (2.40 - mf)) / -0.2;
if (mf > 2.60 || mf < 2.80)
bbo = (0.57 * (mf - 2.80) + 0.55 * (2.60 - mf)) / -0.2;
if (mf > 2.80 || mf < 3.00)
bbo = (0.55 * (mf - 3.00) + 0.53 * (2.80 - mf)) / -0.2;
}
if (Tmn == 19.0)
{
if (mf == 2.40)
bbo = 0.66;
if (mf == 2.60)
bbo = 0.64;
if (mf == 2.80)
bbo = 0.62;
if (mf == 3.00)
bbo = 0.60;
if (mf > 2.40 || mf < 2.60)
bbo = (0.66 * (mf - 2.60) + 0.64* (2.40 - mf)) / -0.2;
if (mf > 2.60 || mf < 2.80)
bbo = (0.64 * (mf - 2.80) + 0.62 * (2.60 - mf)) / -0.2;
if (mf > 2.80 || mf < 3.00)
bbo = (0.62 * (mf - 3.00) + 0.60 * (2.80 - mf)) / -0.2;
}
if (Tmn == 25.4)
{
if (mf == 2.40)
bbo = 0.71;
if (mf == 2.60)
bbo = 0.69;
if (mf == 2.80)
bbo = 0.67;
if (mf == 3.00)
- 23 -
bbo = 0.65;
if (mf > 2.40 || mf < 2.60)
bbo =( 0.71 * (mf - 2.60) + 0.69 * (2.40 - mf)) / -0.2;
if (mf > 2.60 || mf < 2.80)
bbo = (0.69 * (mf - 2.80) + 0.67 * (2.60 - mf)) / -0.2;
if (mf > 2.80 || mf < 3.00)
bbo =( 0.67 * (mf - 3.00) + 0.65 * (2.80 - mf)) / -0.2;
}
if (Tmn == 38.0)
{
if (mf == 2.40)
bbo = 0.76;
if (mf == 2.60)
bbo = 0.74;
if (mf == 2.80)
bbo = 0.72;
if (mf == 3.00)
bbo = 0.70;
if (mf > 2.40 || mf < 2.60)
bbo = (0.76 * (mf - 2.60) + 0.74 * (2.40 - mf)) / -0.2;
if (mf > 2.60 || mf < 2.80)
bbo = (0.74 * (mf - 2.80) + 0.72 * (2.60 - mf)) / -0.2;
if (mf > 2.80 || mf < 3.00)
bbo = (0.72 * (mf - 3.00) + 0.70 * (2.80 - mf)) / -0.2;
}
if (Tmn == 50.8)
{
if (mf == 2.40)
bbo = 0.78;
if (mf == 2.60)
bbo = 0.76;
if (mf == 2.80)
bbo = 0.74;
if (mf == 3.00)
bbo = 0.72;
if (mf > 2.40 || mf < 2.60)
bbo =( 0.78 * (mf - 2.60) + 0.76 * (2.40 - mf)) / -0.2;
if (mf > 2.60 || mf < 2.80)
bbo =( 0.76 * (mf - 2.80) + 0.74 * (2.60 - mf)) / -0.2;
if (mf > 2.80 || mf < 3.00)
bbo =( 0.74 * (mf - 3.00) + 0.72 * (2.80 - mf)) / -0.2;
}
if (Tmn == 76.0)
{
if (mf == 2.40)
bbo = 0.81;
if (mf == 2.60)
bbo = 0.79;
if (mf == 2.80)
bbo = 0.77;
if (mf == 3.00)
bbo = 0.75;
if (mf > 2.40 || mf < 2.60)
bbo = (0.81 * (mf - 2.60) + 0.79 * (2.40 - mf)) / -0.2;
if (mf > 2.60 || mf < 2.80)
bbo = (0.79 * (mf - 2.80) + 0.77 * (2.60 - mf)) / -0.2;
if (mf > 2.80 || mf < 3.00)
bbo =( 0.77 * (mf - 3.00) + 0.75 * (2.80 - mf)) / -0.2;
}
if (Tmn == 152.0)
{
if (mf == 2.40)
bbo = 0.87;
if (mf == 2.60)
bbo = 0.85;
if (mf == 2.80)
bbo = 0.83;
if (mf == 3.00)
bbo = 0.81;
if (mf > 2.40 || mf < 2.60)
bbo = (0.87 * (mf - 2.60) + 0.85 * (2.40 - mf)) / -0.2;
- 24 -
if (mf > 2.60 || mf < 2.80)
bbo = (0.85 * (mf - 2.80) + 0.83 * (2.60 - mf)) / -0.2;
if (mf > 2.80 || mf < 3.00)
bbo = (0.83 * (mf - 3.00) + 0.81 * (2.80 - mf)) / -0.2;
}
Console.WriteLine("El Volumen de agregado grueso(b/bo) =" + bbo);
Console.WriteLine("=========================");
Console.WriteLine("Porfavor todos las datos que ingrese deben ser en Kg/m3,espero su comprension");
Console.WriteLine("Ingrese el contenido de humedad del agregado fino=");
chf=double.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el contenido de humedad del agregado grueso=");
chg = double.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el Porcentaje de absorción del agregado fino=");
pabf = double.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el Porcentaje del agregado grueso=");
pabg = double.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el Peso Unitario compactado seco del agregado grueso en(Kg/m3)=");

pucsg = double.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el Peso Unitario suelto seco del agregado fino en(Kg/m3)=");
pussf = double.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el Peso Unitario suelto seco del agregado grueso en(Kg/m3)=");
pussg = double.Parse(Console.ReadLine());
Console.WriteLine("ingrese el Peso especifico de masa del agregado grueso en (Kg/m3)=");

pedmg=double.Parse(Console.ReadLine());
Console.WriteLine("ingrese el Peso especifico de masa del agregado fino en (Kg/m3)=");
pedmf = double.Parse(Console.ReadLine());
pdag = bbo * pucsg;

pdag = Math.Round(pdag, 2);
Console.WriteLine("El peso del agregado grueso es ="+pdag+"kg");
pes = pe * 1000.0;
cemento = (Math.Round(fcv, 2))*1.0;
agrueso = (Math.Round(pdag, 2))*1.0;
aire = aire * 1.0;
adm = adm * 1.0;
aui = Math.Round(aui, 2);
volaf = (1.0 - (cemento / pes + adm / 1000.0 + agrueso / pedmg + aire / 100.0));
Console.WriteLine("El volumen volaf es ="+volaf);
pdaf = volaf * pedmf;

pdaf = Math.Round(pdaf, 2);
Console.WriteLine("El peso del agregado fino(s)=" + pdaf);
Console.WriteLine("========================================================================================");
Console.WriteLine("Cantidad de materiales por m3(en obra)");
Console.WriteLine("Cemento="+cemento+"Kg"+"\t"+aui+"bolsas o ps3");
pdaf = Math.Round(pdaf, 2);
qwe=pdaf*(1+chf/100);
qwe = Math.Round(qwe, 2);
qwr = pdag * (1 + chg / 100);
qwr = Math.Round(qwr, 2);
sape=chf-pabf;
sapo=chg-pabg;
qwt=(adm-((sape/100.0)*pdaf)-((sapo/100.0)*pdag));
qwt = Math.Round(qwt, 3);
pol=pdaf*35.315/pussf;
pol = Math.Round(pol, 2);
- 25 -
pal = pdag * 35.315 / pussg;
pal = Math.Round(pal, 2);
Console.WriteLine("A.Fino(h)="+qwe+"Kg"+"\t"+pol+"ps3");
Console.WriteLine("A.Grueso(h)=" + qwr+"Kg"+"\t"+pal+"ps3");
Console.WriteLine("Agua efectiva=" + qwt+"L");
Console.WriteLine("Proporciones en peso en obra:");
pc = cemento / cemento;
pc = Math.Round(pc, 2);
pf = qwe / cemento;
pf = Math.Round(pf, 2);
pg = qwr / cemento;
pg = Math.Round(pg, 2);
pa = qwt / cemento;
pa = Math.Round(pa, 3);
vc = aui / aui;
vc = Math.Round(vc, 2);
vf = pol / aui;
vf = Math.Round(vf, 2);
vg = pal / aui;
vg = Math.Round(vg, 2);
va = qwt / aui;
va = Math.Round(va, 2);
Console.WriteLine("\t" + "\t" + "\t" + "\t" + pc + ":" + pf + ":" + pg+"/"+pa);
Console.WriteLine("Proporciones en volumen en obra:");
Console.WriteLine("\t" + "\t" + "\t" + "\t" + vc + ":" + vf + ":" + vg + "/" + va+"Lx bolsa");
Console.WriteLine("MODULO DE FINURA DE LA COMBINACION DE AGREGADOS");
Console.Write("Ingrese el modulo de finura del agregado grueso=");
mg = double.Parse(Console.ReadLine());
if (Tmn == 9.5)
{
if (aui == 6)
mfin = 3.96;
if (aui == 7)
mfin = 4.04;
if (aui == 8)
mfin = 4.11;
if (aui == 9)
mfin = 4.19;
if (aui > 6 || aui < 7)
mfin = (3.96 * (aui - 7) + 4.04 * (6 - aui)) / -1.0;
if (aui > 7 || aui < 8)
mfin = (4.04 * (aui - 8) + 4.11 * (7 - aui)) / -1.0;
if (aui > 8 || aui < 9)
mfin = (4.11 * (aui - 9) + 4.19 * (8 - aui)) / -1.0;
}
if (Tmn == 12.7)
{
if (aui == 6)
mfin = 4.46;
if (aui == 7)
mfin = 4.54;
if (aui == 8)
mfin = 4.61;
if (aui == 9)
mfin = 4.69;
if (aui > 6 || aui < 7)
mfin = (4.46 * (aui - 7) + 4.54 * (6 - aui)) / -1.0;
if (aui > 7 || aui < 8)
- 26 -
mfin = (4.54 * (aui - 8) + 4.61 * (7 - aui)) / -1.0;
if (aui > 8 || aui < 9)
mfin = (4.61 * (aui - 9) + 4.69 * (8 - aui)) / -1.0;
}
if (Tmn == 19.0)
{
if (aui == 6)
mfin = 4.96;
if (aui == 7)
mfin = 5.04;
if (aui == 8)
mfin = 5.11;
if (aui == 9)
mfin = 5.19;
if (aui > 6 || aui < 7)
mfin = (4.96 * (aui - 7) + 5.04 * (6 - aui)) / -1.0;
if (aui > 7 || aui < 8)
mfin = (5.04 * (aui - 8) + 5.11 * (7 - aui)) / -1.0;
if (aui > 8 || aui < 9)
mfin = (5.11 * (aui - 9) + 5.19 * (8 - aui)) / -1.0;
}
if (Tmn == 25.4)
{
if (aui == 6)
mfin = 5.26;
if (aui == 7)
mfin = 5.34;
if (aui == 8)
mfin = 5.41;
if (aui == 9)
mfin = 5.49;
if (aui > 6 || aui < 7)
mfin = (5.26 * (aui - 7) + 5.34 * (6 - aui)) / -1.0;
if (aui > 7 || aui < 8)
mfin = (5.34 * (aui - 8) + 5.41 * (7 - aui)) / -1.0;
if (aui > 8 || aui < 9)
mfin = (5.41 * (aui - 9) + 5.49 * (8 - aui)) / -1.0;
}
if (Tmn == 38.0)
{
if (aui == 6)
mfin = 5.56;
if (aui == 7)
mfin = 5.64;
if (aui == 8)
mfin = 5.71;
if (aui == 9)
mfin = 5.79;
if (aui > 6 || aui < 7)
mfin = (5.56 * (aui - 7) + 5.64 * (6 - aui)) / -1.0;
if (aui > 7 || aui < 8)
mfin = (5.64 * (aui - 8) + 5.71 * (7 - aui)) / -1.0;
if (aui > 8 || aui < 9)
mfin = (5.71 * (aui - 9) + 5.79 * (8 - aui)) / -1.0;
}
if (Tmn == 50.8)
{
if (aui == 6)
mfin = 5.86;
if (aui == 7)
mfin = 5.94;
if (aui == 8)
mfin = 6.01;
if (aui == 9)
mfin = 6.09;
if (aui > 6 || aui < 7)
mfin = (5.86 * (aui - 7) + 5.94 * (6 - aui)) / -1.0;
- 27 -
if (aui > 7 || aui < 8)
mfin = (5.94 * (aui - 8) + 6.01 * (7 - aui)) / -1.0;
if (aui > 8 || aui < 9)
mfin = (6.01 * (aui - 9) + 6.09 * (8 - aui)) / -1.0;
}
if (Tmn == 76.0)
{
if (aui == 6)
mfin = 6.16;
if (aui == 7)
mfin = 6.24;
if (aui == 8)
mfin = 5.31;
if (aui == 9)
mfin = 6.39;
if (aui > 6 || aui < 7)
mfin = (6.16 * (aui - 7) + 6.24 * (6 - aui)) / -1.0;
if (aui > 7 || aui < 8)
mfin = (6.24 * (aui - 8) + 5.31 * (7 - aui)) / -1.0;
if (aui > 8 || aui < 9)
mfin = (5.31 * (aui - 9) + 6.39 * (8 - aui)) / -1.0;
}
mfin = Math.Round(mfin, 2);
Console.WriteLine("El modulo de finura de la combinacion de agregados es =" + mfin);
zf = (mg - mfin) / (mg - mf);
zf = Math.Round(zf, 4);
zg = 1 - zf;
zg = Math.Round(zg, 4);
rf = (zf / pedmf) / ((zf / pedmf) + (zg / pedmg));
rf = Math.Round(rf, 4);
rg = 1 - rf;
rg = Math.Round(rg, 4);
Console.WriteLine("Calculo de volumen de absoluto del agregado total(fino + grueso)");
volab = (1.0 - (cemento / pes + adm / 1000.0 + aire / 100.0));
volab = Math.Round(volab, 4);
volabf = rf * volab;
volabg = rf * volab;
paf = volabf * pedmf;
paf = Math.Round(paf, 2);
pag = volabg * pedmg;
pag = Math.Round(pag, 2);
Console.WriteLine("==========================================================================");
Console.WriteLine("canridad de materiales por metro cubico (en obra)");
Console.WriteLine("Cemento=" + cemento + "Kg" + "\t" + aui + "bolsas o ps3");
rosa = paf * (1 + chf / 100);
rosa = Math.Round(rosa, 2);
evelyn = pag * (1 + chg / 100);
evelyn = Math.Round(evelyn, 2);
val = (adm - ((sape / 100.0) * paf) - ((sapo / 100.0) * pag));
val = Math.Round(val, 2);
benel = paf * 35.315 / pussf;

benel = Math.Round(benel, 2);
invo = pag * 35.315 / pussg;
invo = Math.Round(invo, 2);
Console.WriteLine("A.Fino(h)=" + rosa + "Kg" + "\t" + benel + "ps3");

Console.WriteLine("A.Grueso(h)=" + evelyn + "Kg" + "\t" + invo + "ps3");
Console.WriteLine("Agua efectiva=" + val + "L");
pro = cemento / cemento;

pro = Math.Round(pro, 2);
gra = rosa / cemento;
- 28 -
gra = Math.Round(gra, 2);
ma = evelyn / cemento;
ma = Math.Round(ma, 2);
cion = val / cemento;
cion = Math.Round(cion, 3);
di = aui / aui;
di = Math.Round(di, 2);
gi = benel / aui;
gi = Math.Round(gi, 2);
tal = invo / aui;
tal = Math.Round(tal, 2);
sipi = val / aui;
sipi = Math.Round(sipi, 2);
Console.WriteLine("\t" + "\t" + "\t" + "\t" + pro + ":" + gra + ":" + ma + "/" + cion);
Console.WriteLine("\t" + "\t" + "\t" + "\t" + di + ":" + gi + ":" + tal + "/" + sipi + "Lx bolsa");
Console.WriteLine("**********************************************************************************");
Console.WriteLine("PROPORCIONES (PESO Y VOLUMEN)EN OBRA POR METRO CUBICO POR METODO ACI");
Console.WriteLine("----------------------------------------------------");
Console.WriteLine("\t" + "\t" + "\t" + "\t" + pc + ":" + pf + ":" + pg + "/" + pa);
Console.WriteLine("\t" + "\t" + "\t" + "\t" + vc + ":" + vf + ":" + vg + "/" + va + "Lx bolsa");
Console.WriteLine("****************************************************************************");
Console.WriteLine("PROPORCIONES (PESO Y VOLUMEN)EN OBRA POR METRO CUBICO POR METODO DE COMBINACION DE
AGREGADOS");
Console.WriteLine("*******************************************************************************");
Console.WriteLine("\t" + "\t" + "\t" + "\t" + pro + ":" + gra + ":" + ma + "/" + cion);
Console.WriteLine("\t" + "\t" + "\t" + "\t" + di + ":" + gi + ":" + tal + "/" + sipi + "Lx bolsa");
Console.WriteLine("============================================================");
Console.WriteLine("**********Fin del programa**************");
Console.WriteLine("♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
- 29 -
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀
♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀♀");
Console.WriteLine("Algun comentario y/o desea extender este programa o obtener mas resultados etc.etc. Comunicarce al
numero*945091661*o al email:yean_420@hotmail.com");
Console.WriteLine("Gracias");
Console.WriteLine("________________________________________________________________________");
Console.ReadLine();
}
}
}
________________________________________________
6.7. Pruebas del programa
6.7.1. Resolución manual del caso
6.7.2. Resolución usando el software desarrollado (Captura de

Pantallas)
- 30 -
- 31 -
- 32 -
- 33 -
- 34 -
- 35 -
- 36 -
- 37 -
VI. CONCLUCIONES Y RECOMENDACIONES:
-Seguir los pasos al pie de la letra como se indica en el programa.

-Colocar datos reales en el programa ,ya que estas entorpecerían los
resultados
-Si desea alguna ayuda, modificación o insertar nuevas variables ; al final
del programa se encuentran los datos requeridos.
Correo: yean.mpc@gmail.com
- 38 -
- 39 -

Proyecto de Programación DISEÑO DE MEZCLA - Paucara Coaguila Yean Martin

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Proyecto de Programación DISEÑO DE MEZCLA - Paucara Coaguila Yean Martin

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSIDAD RICARDO PALMA

ESCUELA PROFESIONAL DE INGENIERÍA CIVIL

TITULO: Diseño de mezclas de Hormigón (Concreto)

PROYECTO DE PROGRAMACIÓN PRESENTADO POR

I. PLANTEAMIENT DEL PROBLEMA ................................................................ 3

1.1 Planteamiento del problema:

Materiales que intervienen en una mezcla de concreto son el cemento, agua,

-El método del ACI

Al diseñar una mezcla de concreto y/o en la búsqueda de las proporciones en

1.2 Formulación y delimitación del problema

1.2.1 Problema general:

1.2.2 Problemas específicos:

Como optimizamos el uso de los estándares en el diseño de diseño de

1.3 Importancia del proyecto:

2.1. Objetivo general:

Determinar la cantidad de materiales para la elaboración del diseño de mezcla de

2.2 Objetivos específicos:

III. MARCO TEORICO

Mezcla de Hormigón (concreto)

El concreto es la mezcla del cemento, agregados inertes (arena y grava) y

3.2 Definición de términos básicos

El cemento es un conglomerante formado a partir de unas mezclas de caliza y

El agua, considerada como materia prima para la confección y el curado del

Los aditivos para hormigón (concreto) son componentes de naturaleza orgánica

ACI: Instituto Americano del Concreto

4.1 Hipótesis General:

4.2 Hipótesis Específica:

Desarrollando un programa en mejoraríamos las proporciones en obra y así

Optimizando el uso de los estándares en el diseño de diseño de mezclas

6.1. Enunciado resumen del caso a desarrollar:

EL método del ACI y método de combinación de agregado son usados con

6.2. Definición de nombres de variables a utilizar:

6.3. Definición de variables de entrada y Salida

6.4. Definición de los tipos de datos a emplear

int= Entero que almacena datos (-2.147.483.648 a 2.147.483.647).

6.5. Desarrollo del Algoritmo (Diagrama de Flujo)

Console.WriteLine("El valor de F'cr=" + Fcrc + "Kg/cm2");

Console.WriteLine("La Relacion agua/cemento (a/c)=" + acem);

if (acem < menor)

fcv = +adm / menor;

Console.WriteLine("El factor cemento (F.C)=" + Math.Round(fcv,2));

Console.WriteLine("Ingrese el Peso Unitario compactado seco del agregado grueso en(Kg/m3)=");

Console.WriteLine("ingrese el Peso especifico de masa del agregado grueso en (Kg/m3)=");

pdag = bbo * pucsg;

Console.WriteLine("El volumen volaf es ="+volaf);

pdaf = volaf * pedmf;

benel = paf * 35.315 / pussf;

Console.WriteLine("A.Fino(h)=" + rosa + "Kg" + "\t" + benel + "ps3");

pro = cemento / cemento;

6.7.1. Resolución manual del caso

6.7.2. Resolución usando el software desarrollado (Captura de

-Seguir los pasos al pie de la letra como se indica en el programa.

Vous aimerez peut-être aussi