Example #1
0
        public static double CalcularImporteAguaDomestica1(ConexionSQLite conex, int grupo, int categoria, double volumen, int periodo)
        {
            double importe = 0;

            if (grupo == 10)
            {
                double tarifa_0_a_8 = conex.ObtenerTarifaAgua(grupo, categoria, 12, periodo);
                importe = tarifa_0_a_8 * volumen;
            }
            else
            {
                double tarifa_0_a_8    = conex.ObtenerTarifaAgua(grupo, categoria, 3, periodo);
                double tarifa_8_a_25   = conex.ObtenerTarifaAgua(grupo, categoria, 4, periodo);
                double tarifa_25_a_mas = conex.ObtenerTarifaAgua(grupo, categoria, 6, periodo);

                if (volumen <= 8)
                {
                    importe = tarifa_0_a_8 * volumen;
                }
                else
                {
                    if (volumen <= 25)
                    {
                        importe = 8 * tarifa_0_a_8 + (volumen - 8) * tarifa_8_a_25;
                    }
                    else
                    {
                        importe = 8 * tarifa_0_a_8 + 17 * tarifa_8_a_25 + (volumen - 25) * tarifa_25_a_mas;
                    }
                }
            }

            return(Math.Truncate(100 * importe) / 100);
        }
Example #2
0
        public static Double calcular_volumen_alc_social(ConexionSQLite conex, int grupo, int categoria, int importe, int periodo)
        {
            double vol_agua;
            double trf_0_10;
            double trf_10_mas;

            if (grupo == 10)
            {
                trf_0_10 = conex.ObtenerTarifaDesague(grupo, 6, 12, periodo);
                vol_agua = importe / trf_0_10;
            }
            else
            {
                trf_0_10   = conex.ObtenerTarifaDesague(grupo, 6, 1, periodo);
                trf_10_mas = conex.ObtenerTarifaDesague(grupo, 6, 2, periodo);
                if (importe <= trf_0_10 * 10)
                {
                    vol_agua = importe / trf_0_10;
                }
                else
                {
                    vol_agua = 10 + (importe - 10 * trf_0_10) / trf_10_mas;
                }
            }
            vol_agua = Math.Truncate(vol_agua * 100) / 100;
            return(vol_agua);
        }
Example #3
0
        public static double CalcularImporteAlcantarilladoComercialIndustrial(ConexionSQLite conex, int grupo, int categoria, double volumen, int periodo)
        {
            double importe = 0;

            if (grupo == 10)
            {
                double tarifa_0_a_50 = conex.ObtenerTarifaDesague(grupo, categoria, 12, periodo);
                importe = tarifa_0_a_50 * volumen;
            }
            else
            {
                double tarifa_0_a_50    = conex.ObtenerTarifaDesague(grupo, categoria, 8, periodo);
                double tarifa_50_a_150  = conex.ObtenerTarifaDesague(grupo, categoria, 9, periodo);
                double tarifa_150_a_mas = conex.ObtenerTarifaDesague(grupo, categoria, 10, periodo);

                if (volumen <= 50)
                {
                    importe = tarifa_0_a_50 * volumen;
                }
                else
                {
                    if (volumen <= 150)
                    {
                        importe = 50 * tarifa_0_a_50 + (volumen - 50) * tarifa_50_a_150;
                    }
                    else
                    {
                        importe = 150 * tarifa_50_a_150 + (volumen - 150) * tarifa_150_a_mas;
                    }
                }
            }

            return(Math.Truncate(100 * importe) / 100);
        }
Example #4
0
        public static Double calcular_volumen_alc_domestica2_morropon(ConexionSQLite conex, int grupo, int importe, int periodo)
        {
            double vol_agua;
            double trf_0_8;
            double trf_8_25;
            double trf_25_mas;

            trf_0_8    = conex.ObtenerTarifaDesague(grupo, 1, 3, periodo);
            trf_8_25   = conex.ObtenerTarifaDesague(grupo, 1, 4, periodo);
            trf_25_mas = conex.ObtenerTarifaDesague(grupo, 1, 6, periodo);
            if (importe <= trf_0_8 * 8)
            {
                vol_agua = importe / trf_0_8;
            }
            else
            {
                if (importe <= trf_0_8 * 8 + trf_8_25 * 17)
                {
                    vol_agua = 8 + (importe - 8 * trf_0_8) / trf_8_25;
                }
                else
                {
                    vol_agua = 25 + (importe - 8 * trf_0_8 - 17 * trf_25_mas) / trf_25_mas;
                }
            }
            vol_agua = Math.Truncate(vol_agua * 100) / 100;
            return(vol_agua);
        }
Example #5
0
        public static double CalcularImporteAlcantarilladoNoResidencialMorropon(ConexionSQLite conex, int grupo, int categoria, double volumen, int periodo)
        {
            double importe         = 0;
            double tarifa_0_50     = conex.ObtenerTarifaDesague(grupo, categoria, 8, periodo);
            double tarifa_50_a_mas = conex.ObtenerTarifaDesague(grupo, categoria, 11, periodo);

            if (volumen <= 50)
            {
                importe = tarifa_0_50 * volumen;
            }
            else
            {
                importe = 50 * tarifa_0_50 + (volumen - 50) * tarifa_50_a_mas;
            }
            return(Math.Truncate(100 * importe) / 100);
        }
Example #6
0
        public static Double calcular_volumen_alc_domestica2(ConexionSQLite conex, int grupo, int importe, int periodo)
        {
            double vol_agua;
            double trf_0_8;
            double trf_8_25;
            double trf_25_100;
            double trf_100_mas;

            if (grupo == 10)
            {
                trf_0_8  = conex.ObtenerTarifaDesague(grupo, 2, 12, periodo);
                vol_agua = importe / trf_0_8;
            }
            else
            {
                trf_0_8     = conex.ObtenerTarifaDesague(grupo, 2, 3, periodo);
                trf_8_25    = conex.ObtenerTarifaDesague(grupo, 2, 4, periodo);
                trf_25_100  = conex.ObtenerTarifaDesague(grupo, 2, 5, periodo);
                trf_100_mas = conex.ObtenerTarifaDesague(grupo, 2, 7, periodo);
                if (importe <= trf_0_8 * 8)
                {
                    vol_agua = importe / trf_0_8;
                }
                else
                {
                    if (importe <= trf_0_8 * 8 + trf_8_25 * 17)
                    {
                        vol_agua = 8 + (importe - 8 * trf_0_8) / trf_8_25;
                    }
                    else
                    {
                        if (importe <= 8 * trf_0_8 + 17 * trf_8_25 + 75 * trf_25_100)
                        {
                            vol_agua = 25 + (importe - 8 * trf_0_8 - 17 * trf_8_25) / trf_25_100;
                        }
                        else
                        {
                            vol_agua = 100 + (importe - 8 * trf_0_8 - 17 * trf_8_25 - 75 * trf_25_100) / trf_100_mas;
                        }
                    }
                }
            }
            vol_agua = Math.Truncate(vol_agua * 100) / 100;
            return(vol_agua);
        }
Example #7
0
        public static Double calcular_volumen_alc_no_residencial_morropon(ConexionSQLite conex, int grupo, int categoria, int importe, int periodo)
        {
            double vol_agua;
            double trf_0_50;
            double trf_50_mas;

            trf_0_50   = conex.ObtenerTarifaDesague(grupo, categoria, 8, periodo);
            trf_50_mas = conex.ObtenerTarifaDesague(grupo, categoria, 11, periodo);
            if (importe <= trf_0_50 * 50)
            {
                vol_agua = importe / trf_0_50;
            }
            else
            {
                vol_agua = 50 + (importe - 50 * trf_0_50) / trf_50_mas;
            }
            vol_agua = Math.Truncate(vol_agua * 100) / 100;
            return(vol_agua);
        }
Example #8
0
        public static double CalcularImporteAguaSocial(ConexionSQLite conex, int grupo, int categoria, double volumen, int periodo)
        {
            double importe = 0;

            if (grupo == 10)
            {
                double tarifa_0_a_10 = conex.ObtenerTarifaAgua(grupo, categoria, 12, periodo);
                importe = tarifa_0_a_10 * volumen;
            }
            else
            {
                double tarifa_0_a_10   = conex.ObtenerTarifaAgua(grupo, categoria, 1, periodo);
                double tarifa_10_a_mas = conex.ObtenerTarifaAgua(grupo, categoria, 2, periodo);
                if (volumen <= 10)
                {
                    importe = tarifa_0_a_10 * volumen;
                }
                else
                {
                    importe = 10 * tarifa_0_a_10 + (volumen - 10) * tarifa_10_a_mas;
                }
            }
            return(Math.Truncate(100 * importe) / 100);
        }
Example #9
0
        static Double calcular_volumen_alc_comercial_industrial(ConexionSQLite conex, int grupo, int categoria, int importe, int periodo)
        {
            double vol_agua;
            double trf_0_50;
            double trf_50_150;
            double trf_150_mas;

            if (grupo == 10)
            {
                trf_0_50 = conex.ObtenerTarifaDesague(grupo, categoria, 12, periodo);
                vol_agua = importe / trf_0_50;
            }
            else
            {
                trf_0_50    = conex.ObtenerTarifaDesague(grupo, categoria, 8, periodo);
                trf_50_150  = conex.ObtenerTarifaDesague(grupo, categoria, 9, periodo);
                trf_150_mas = conex.ObtenerTarifaDesague(grupo, categoria, 10, periodo);
                if (importe <= trf_0_50 * 50)
                {
                    vol_agua = importe / trf_0_50;
                }
                else
                {
                    if (importe <= trf_0_50 * 150)
                    {
                        vol_agua = 50 + (importe - 50 * trf_0_50) / trf_150_mas;
                    }
                    else
                    {
                        vol_agua = 150 + (importe - 150 * trf_50_150) / trf_150_mas;
                    }
                }
            }
            vol_agua = Math.Truncate(vol_agua * 100) / 100;
            return(vol_agua);
        }
Example #10
0
        public static Double calcular_volumen_agua_estatal(ConexionSQLite conex, int grupo, int importe, int periodo)
        {
            double vol_agua;
            double trf_0_50;
            double trf_50_150;
            double trf_150_mas;

            if (grupo == 10)
            {
                trf_0_50 = conex.ObtenerTarifaAgua(grupo, 5, 12, periodo);
                vol_agua = importe / trf_0_50;
            }
            else
            {
                trf_0_50    = conex.ObtenerTarifaAgua(grupo, 5, 8, periodo);
                trf_50_150  = conex.ObtenerTarifaAgua(grupo, 5, 9, periodo);
                trf_150_mas = conex.ObtenerTarifaAgua(grupo, 5, 10, periodo);
                if (importe <= trf_0_50 * 50)
                {
                    vol_agua = importe / trf_0_50;
                }
                else
                {
                    if (importe <= trf_0_50 * 50 + trf_50_150 * 100)
                    {
                        vol_agua = 50 + (importe - 50 * trf_0_50) / trf_50_150;
                    }
                    else
                    {
                        vol_agua = 150 + (importe - 150 * trf_50_150) / trf_150_mas;
                    }
                }
            }
            vol_agua = Math.Truncate(vol_agua * 100) / 100;
            return(vol_agua);
        }
Example #11
0
        public static List <BaseBD> Analisis(ConexionSQLite conex, int periodo, List <BaseBD> bases)
        {
            foreach (BaseBD baseBD in bases)
            {
                switch (baseBD.codamb)
                {
                case 1:
                    switch (baseBD.nomcat)
                    {
                    case "DOMESTICA 1":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica1(conex, 1, 1, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica1(conex, 1, 1, baseBD.volfac, periodo);
                        break;

                    case "DOMESTICA 2":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica2(conex, 1, 2, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica2(conex, 1, 2, baseBD.volfac, periodo);
                        break;

                    case "COMERCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 1, 3, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 1, 3, baseBD.volfac, periodo);
                        break;

                    case "INDUSTRIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 1, 4, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 1, 4, baseBD.volfac, periodo);
                        break;

                    case "ESTATAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaEstatal(conex, 1, 5, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoEstatal(conex, 1, 5, baseBD.volfac, periodo);
                        break;

                    case "SOCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaSocial(conex, 1, 6, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoSocial(conex, 1, 6, baseBD.volfac, periodo);
                        break;
                    }
                    break;

                case 2:
                    switch (baseBD.nomcat)
                    {
                    case "DOMESTICA 1":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica1(conex, 2, 1, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica1(conex, 2, 1, baseBD.volfac, periodo);
                        break;

                    case "DOMESTICA 2":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica2(conex, 2, 2, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica2(conex, 2, 2, baseBD.volfac, periodo);
                        break;

                    case "COMERCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 2, 3, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 2, 3, baseBD.volfac, periodo);
                        break;

                    case "INDUSTRIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 2, 4, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 2, 4, baseBD.volfac, periodo);
                        break;

                    case "ESTATAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaEstatal(conex, 2, 5, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoEstatal(conex, 2, 5, baseBD.volfac, periodo);
                        break;

                    case "SOCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaSocial(conex, 2, 6, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoSocial(conex, 2, 6, baseBD.volfac, periodo);
                        break;
                    }
                    break;

                case 3:
                    switch (baseBD.nomcat)
                    {
                    case "DOMESTICA 1":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica1(conex, 3, 1, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica1(conex, 3, 1, baseBD.volfac, periodo);
                        break;

                    case "DOMESTICA 2":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica2(conex, 3, 2, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica2(conex, 3, 2, baseBD.volfac, periodo);
                        break;

                    case "COMERCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 3, 3, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 3, 3, baseBD.volfac, periodo);
                        break;

                    case "INDUSTRIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 3, 4, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 3, 4, baseBD.volfac, periodo);
                        break;

                    case "ESTATAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaEstatal(conex, 3, 5, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoEstatal(conex, 3, 5, baseBD.volfac, periodo);
                        break;

                    case "SOCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaSocial(conex, 3, 6, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoSocial(conex, 3, 6, baseBD.volfac, periodo);
                        break;
                    }
                    break;

                case 4:
                    switch (baseBD.nomcat)
                    {
                    case "DOMESTICA 1":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica1(conex, 4, 1, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica1(conex, 4, 1, baseBD.volfac, periodo);
                        break;

                    case "DOMESTICA 2":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica2(conex, 4, 2, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica2(conex, 4, 2, baseBD.volfac, periodo);
                        break;

                    case "COMERCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 4, 3, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 4, 3, baseBD.volfac, periodo);
                        break;

                    case "INDUSTRIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 4, 4, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 4, 4, baseBD.volfac, periodo);
                        break;

                    case "ESTATAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaEstatal(conex, 4, 5, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoEstatal(conex, 4, 5, baseBD.volfac, periodo);
                        break;

                    case "SOCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaSocial(conex, 4, 6, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoSocial(conex, 4, 6, baseBD.volfac, periodo);
                        break;
                    }
                    break;

                case 5:
                    switch (baseBD.nomcat)
                    {
                    case "DOMESTICA 1":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica1(conex, 5, 1, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica1(conex, 5, 1, baseBD.volfac, periodo);
                        break;

                    case "DOMESTICA 2":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica2(conex, 5, 2, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica2(conex, 5, 2, baseBD.volfac, periodo);
                        break;

                    case "COMERCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 5, 3, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 5, 3, baseBD.volfac, periodo);
                        break;

                    case "INDUSTRIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 5, 4, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 5, 4, baseBD.volfac, periodo);
                        break;

                    case "ESTATAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaEstatal(conex, 5, 5, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoEstatal(conex, 5, 5, baseBD.volfac, periodo);
                        break;

                    case "SOCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaSocial(conex, 5, 6, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoSocial(conex, 5, 6, baseBD.volfac, periodo);
                        break;
                    }
                    break;

                case 6:
                    switch (baseBD.nomcat)
                    {
                    case "DOMESTICA 1":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica1(conex, 6, 1, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica1(conex, 6, 1, baseBD.volfac, periodo);
                        break;

                    case "DOMESTICA 2":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica2(conex, 6, 2, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica2(conex, 6, 2, baseBD.volfac, periodo);
                        break;

                    case "COMERCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 6, 3, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 6, 3, baseBD.volfac, periodo);
                        break;

                    case "INDUSTRIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 6, 4, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 6, 4, baseBD.volfac, periodo);
                        break;

                    case "ESTATAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaEstatal(conex, 6, 5, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoEstatal(conex, 6, 5, baseBD.volfac, periodo);
                        break;

                    case "SOCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaSocial(conex, 6, 6, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoSocial(conex, 6, 6, baseBD.volfac, periodo);
                        break;
                    }
                    break;

                case 7:
                    switch (baseBD.nomcat)
                    {
                    case "DOMESTICA 1":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica1(conex, 7, 1, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica1(conex, 7, 1, baseBD.volfac, periodo);
                        break;

                    case "DOMESTICA 2":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica2(conex, 7, 2, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica2(conex, 7, 2, baseBD.volfac, periodo);
                        break;

                    case "COMERCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 7, 3, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 7, 3, baseBD.volfac, periodo);
                        break;

                    case "INDUSTRIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 7, 4, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 7, 4, baseBD.volfac, periodo);
                        break;

                    case "ESTATAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaEstatal(conex, 7, 5, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoEstatal(conex, 7, 5, baseBD.volfac, periodo);
                        break;

                    case "SOCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaSocial(conex, 7, 6, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoSocial(conex, 7, 6, baseBD.volfac, periodo);
                        break;
                    }
                    break;

                case 8:
                    switch (baseBD.nomcat)
                    {
                    case "DOMESTICA 1":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica1(conex, 8, 1, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica1(conex, 8, 1, baseBD.volfac, periodo);
                        break;

                    case "DOMESTICA 2":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica2(conex, 8, 2, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica2(conex, 8, 2, baseBD.volfac, periodo);
                        break;

                    case "COMERCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 8, 3, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 8, 3, baseBD.volfac, periodo);
                        break;

                    case "INDUSTRIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 8, 4, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 8, 4, baseBD.volfac, periodo);
                        break;

                    case "ESTATAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaEstatal(conex, 8, 5, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoEstatal(conex, 8, 5, baseBD.volfac, periodo);
                        break;

                    case "SOCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaSocial(conex, 8, 6, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoSocial(conex, 8, 6, baseBD.volfac, periodo);
                        break;
                    }
                    break;

                case 10:
                    switch (baseBD.nomcat)
                    {
                    case "DOMESTICA 1":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica1(conex, 10, 1, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica1(conex, 10, 1, baseBD.volfac, periodo);
                        break;

                    case "DOMESTICA 2":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaDomestica2(conex, 10, 2, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoDomestica2(conex, 10, 2, baseBD.volfac, periodo);
                        break;

                    case "COMERCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 10, 3, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 10, 3, baseBD.volfac, periodo);
                        break;

                    case "INDUSTRIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaComercialIndustrial(conex, 10, 4, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoComercialIndustrial(conex, 10, 4, baseBD.volfac, periodo);
                        break;

                    case "ESTATAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaEstatal(conex, 10, 5, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoEstatal(conex, 10, 5, baseBD.volfac, periodo);
                        break;

                    case "SOCIAL":
                        baseBD.imagua_nuevo = CalculoImportes.CalcularImporteAguaSocial(conex, 10, 6, baseBD.volfac, periodo);
                        baseBD.imalca_nuevo = CalculoImportes.CalcularImporteAlcantarilladoSocial(conex, 10, 6, baseBD.volfac, periodo);
                        break;
                    }
                    break;
                }
                if (baseBD.imagua_nuevo < 0)
                {
                    baseBD.imagua_nuevo = 0;
                }
                if (baseBD.imalca_nuevo < 0)
                {
                    baseBD.imalca_nuevo = 0;
                }
            }

            return(bases);
        }