Example #1
0
        public static float MisturaMinM(ProcTubo procTubo)      // AM
        {
            float result;

            using (var db = new ApplicationDbContext())
            {
                string temp  = XmlReader.Read("TempoPadraoMistura"); //25
                float  tempo = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                temp = XmlReader.Read("EficPadraoOpTubo");           //9
                float eficacia = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                temp = XmlReader.Read("TempoOcupacaoMOMIstura");     //31
                float ocupacao = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                result = tempo / procTubo.QtPCusto / eficacia * ocupacao;
            }

            return(result);
        }
Example #2
0
        public static float Peneiramento(ProcTubo procTubo)     // AL
        {
            float result;

            using (var db = new ApplicationDbContext())
            {
                string temp     = XmlReader.Read("EficPadraoOpTubo");
                float  eficacia = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                temp = XmlReader.Read("TempoPeneiramento");
                float tempo = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                temp = XmlReader.Read("TaxaOcupacaoMOPesagem");
                float ocupacao = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                result = procTubo.PesoUnKgMLiq * tempo / eficacia * ocupacao;
            }

            return(result);
        }
Example #3
0
        public ActionResult Create([Bind(Include = "Id,ProdutoId,ResinaBaseId,DiamExterno,DiamInterno,SerieId,Carga1Id,PctCarga1,Carga2Id,PctCarga2,Sinterizado,CodResinaAdotada,RrMaxResina,BicoIdeal,MandrilIdeal,SecaoExtrudado,PerimSecaoExtrud,DiamExtFinalTubo,DiamIntFinalTubo,PesoUnKgMLiq,PtfeKgM,LubrKgM,CodPreformaIdeal,Rr,LanceSinterizado,FatorMultiplQtde,QtPf,EmbalagemId,QuantEmbalagem,ProcessoContinuo,VextrUmidoMin,FatorMultiplVExter,VsintMMin,FatorMultiplVelSint,VSintResultante,TesteEstqEsto,ConfAdtDosLub,Peneiramento,MisturaMinM,PreparoExtrusMinM,VelEfetExtrusaoMMin,TuSinterizadoMinM,TuProducaoMinM,TuInspUdc3MinM,TuTesteEstanqMinM,TuTesteEstouroMinM,TuEmbalMinM,TuTotalMinM,CustoPtfeRsM,CustoAditivosRsM,CustoLubrifRsM,CustoEmbalRsM,CustoModRsM,CustoDiretoTotalRsM,CustoIndiretoRsM,CustoTotalRsM,PvRsKg,CapProducaoMH,QtPCusto,PvCalculadoRsM")] ProcTubo procTubo)
        {
            if (ModelState.IsValid)
            {
                db.ProcTubos.Add(procTubo);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.Carga1Id     = new SelectList(db.Cargas, "Id", "Apelido", procTubo.Carga1Id);
            ViewBag.Carga2Id     = new SelectList(db.Cargas, "Id", "Apelido", procTubo.Carga2Id);
            ViewBag.EmbalagemId  = new SelectList(db.Embals, "Id", "Sigla", procTubo.EmbalagemId);
            ViewBag.ProdutoId    = new SelectList(db.Produtos, "Id", "Apelido", procTubo.ProdutoId);
            ViewBag.ResinaBaseId = new SelectList(db.ResinasBase, "Id", "Apelido", procTubo.ResinaBaseId);
            ViewBag.SerieId      = new SelectList(db.Series, "Id", "Apelido", procTubo.SerieId);
            return(View(procTubo));
        }
Example #4
0
        public static float MandrilIdeal(ProcTubo procTubo)
        {
            float result = 0;

            if (procTubo.Sinterizado)
            {
                result = procTubo.ResinaBase.Apelido == XmlReader.Read("Branco")
                    ? 0.97f
                    : 0.93f;
            }

            else
            {
                result = 1;
            }

            return(Function.Ceiling(procTubo.DiamInterno / result, 0.05f));
        }
Example #5
0
        public static float LubrKgM(ProcTubo procTubo)      // V
        {
            float result;

            using (var db = new ApplicationDbContext())
            {
                string comp   = XmlReader.Read("SucatasAparasTubos");
                var    sucata = db.PadroesFixos.Single(p => p.Descricao == comp);
                comp = XmlReader.Read("LubrificantePctPadrao");
                var   lubrificante = db.PadroesFixos.Single(p => p.Descricao == comp);
                float intermediate = (procTubo.PesoUnKgMLiq / (1 - sucata.Valor)) * lubrificante.Valor;
                int   round        = intermediate * 1_000f > 10f
                    ? 3
                    : 4;
                result = (float)Math.Round(intermediate, round);
            }

            return(result);
        }
Example #6
0
        public static float TuProducaoMinM(ProcTubo procTubo)       // AQ
        {
            float result = float.MaxValue;

            using (var db = new ApplicationDbContext())
            {
                string temp     = XmlReader.Read("EficPadraoOpTubo");
                float  eficacia = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;

                if (eficacia > Global.Tolerance && procTubo.TuSinterizadoMinM < Global.Infinity)
                {
                    result = procTubo.VelEfetExtrusaoMMin < Global.Tolerance
                    ? procTubo.TuSinterizadoMinM / eficacia
                    : (1 / procTubo.VelEfetExtrusaoMMin + procTubo.TuSinterizadoMinM) / eficacia;
                }
            }

            return(result);
        }
Example #7
0
        public static float VelEfetExtrusaoMMin(ProcTubo procTubo)      // AO
        {
            float result = 0;

            using (var db = new ApplicationDbContext())
            {
                if (!procTubo.ProcessoContinuo)
                {
                    var comprimento = db.PreFormas.SingleOrDefault(p => p.PreFormaNum == procTubo.CodPreformaIdeal);

                    if (comprimento != null)
                    {
                        result = procTubo.LanceSinterizado / (comprimento.Comprimento / 1_000f * procTubo.Rr / (procTubo.VextrUmidoMin * procTubo.FatorMultiplVExter) + comprimento.TrocaPf);
                    }
                }
            }

            return(result);
        }
Example #8
0
        public static float RrMaxResina(ProcTubo procTubo)      // M
        {
            float result = 0;

            using (var db = new ApplicationDbContext())
            {
                var resina = db.ResinasPtfe.SingleOrDefault(r => r.Ref == procTubo.CodResinaAdotada);
                if (resina == null)
                {
                    DbLogger.Log(Reason.Error, $"Resina {procTubo.CodResinaAdotada} não encontrada em RrMaxResina");
                }
                else
                {
                    result = resina.MaxRr;
                }
            }

            return(result);
        }
Example #9
0
        public static float TuSinterizadoMinM(ProcTubo procTubo)        // AP
        {
            float result;

            using (var db = new ApplicationDbContext())
            {
                string temp     = XmlReader.Read("OcupacaoMOSinterizacao"); //34
                float  ocupacao = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                temp = XmlReader.Read("EficPadraoOpTubo");                  //9
                float eficacia     = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                float intermediate = procTubo.ProcessoContinuo
                    ? 1
                    : ocupacao;
                result = procTubo.VSintResultante > Global.Tolerance
                    ? (float)(Math.Round(1 / procTubo.VSintResultante, 3) / eficacia * intermediate)
                    : float.MaxValue;
            }

            return(result);
        }
Example #10
0
        public static float TuTesteEstouroMinM(ProcTubo procTubo)        // AT
        {
            float result = 0;

            if (procTubo.TesteEstqEsto)
            {
                using (var db = new ApplicationDbContext())
                {
                    string temp   = XmlReader.Read("EnsaioEstouro");     //11
                    float  ensaio = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                    temp = XmlReader.Read("EficPadraoOpTubo");           //9
                    float eficacia = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                    temp = XmlReader.Read("TaxaOcupacaoMOTesteEstouro"); //35
                    float ocupacao = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                    result = ensaio / procTubo.QtPCusto / eficacia * ocupacao;
                }
            }

            return(result);
        }
Example #11
0
        public static float TuEmbalMinM(ProcTubo procTubo)        // AU
        {
            float result;

            using (var db = new ApplicationDbContext())
            {
                string temp        = XmlReader.Read("TempoEmbalamento"); //23
                float  embalamento = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                temp = XmlReader.Read("EficPadraoOpTubo");               //9
                float eficacia = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                temp = XmlReader.Read("TaxaOcupacaoEmbalamento");        //28
                float ocupacao     = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                float intermediate = Math.Abs(procTubo.QuantEmbalagem) > Global.Tolerance
                    ? (float)Function.Ceiling(procTubo.QtPCusto / procTubo.QuantEmbalagem, 1)
                    : 0;
                result = intermediate * embalamento / procTubo.QtPCusto / eficacia * ocupacao;
            }

            return(result);
        }
Example #12
0
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            ProcTubo procTubo = db.ProcTubos.Find(id);

            if (procTubo == null)
            {
                return(HttpNotFound());
            }
            ViewBag.Carga1Id     = new SelectList(db.Cargas, "Id", "Apelido", procTubo.Carga1Id);
            ViewBag.Carga2Id     = new SelectList(db.Cargas, "Id", "Apelido", procTubo.Carga2Id);
            ViewBag.EmbalagemId  = new SelectList(db.Embals, "Id", "Sigla", procTubo.EmbalagemId);
            ViewBag.ProdutoId    = new SelectList(db.Produtos, "Id", "Apelido", procTubo.ProdutoId);
            ViewBag.ResinaBaseId = new SelectList(db.ResinasBase, "Id", "Apelido", procTubo.ResinaBaseId);
            ViewBag.SerieId      = new SelectList(db.Series, "Id", "Apelido", procTubo.SerieId);
            return(View(procTubo));
        }
Example #13
0
        public static int LanceSinterizado(ProcTubo procTubo)       // Y
        {
            int result = 0;

            using (var db = new ApplicationDbContext())
            {
                if (procTubo.Cadastro != "--")
                {
                    var comprimento = db.PreFormas.SingleOrDefault(p => p.PreFormaNum == procTubo.CodPreformaIdeal);

                    if (comprimento != null)
                    {
                        string comp   = XmlReader.Read("SucatasAparasTubos");
                        var    sucata = db.PadroesFixos.Single(p => p.Descricao == comp);
                        result = (int)Function.Multiplo((float)Math.Floor(comprimento.Comprimento / 1_000f * procTubo.Rr * (1 - sucata.Valor) * 0.65f), 5);
                    }
                }
            }

            return(result);
        }
Example #14
0
        public static float TuTotalMinM(ProcTubo procTubo)      // AV
        {
            float intermediate = 0;

            if (procTubo.VelEfetExtrusaoMMin > Global.Tolerance)
            {
                using (var db = new ApplicationDbContext())
                {
                    string temp     = XmlReader.Read("TaxaOcupacaoMOExtrusao"); //29
                    float  ocupacao = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                    temp = XmlReader.Read("EficPadraoOpTubo");                  //9
                    float eficacia = db.PadroesFixos.Single(p => p.Descricao == temp).Valor;
                    intermediate = 1 / procTubo.VelEfetExtrusaoMMin * ocupacao / eficacia;
                }
            }

            return(procTubo.ConfAdtDosLub + procTubo.Peneiramento + procTubo.MisturaMinM +
                   procTubo.PreparoExtrusMinM + intermediate + procTubo.TuSinterizadoMinM +
                   procTubo.TuInspUdc3MinM + procTubo.TuTesteEstanqMinM + procTubo.TuTesteEstouroMinM +
                   procTubo.TuEmbalMinM);
        }
Example #15
0
        public static float DiamIntFinalTubo(ProcTubo procTubo)     //~S
        {
            float result = 0;

            if (procTubo.Cadastro != "--")
            {
                if (procTubo.Sinterizado)
                {
                    result = procTubo.ResinaBase.Apelido == XmlReader.Read("Branco")
                        ? 0.97f
                        : 0.93f;
                }

                else
                {
                    result = 1;
                }
            }

            return(procTubo.MandrilIdeal * result);
        }
Example #16
0
        public static float Rr(ProcTubo procTubo)     // X
        {
            float result = 0;

            if (procTubo.Cadastro != "--")
            {
                using (var db = new ApplicationDbContext())
                {
                    var preforma = db.PreFormas.SingleOrDefault(p => p.PreFormaNum == procTubo.CodPreformaIdeal);
                    if (preforma == null)
                    {
                        DbLogger.Log(Reason.Error, $"Preforma {procTubo.CodPreformaIdeal} não encontrada em Rr");
                    }
                    else
                    {
                        result = (float)Math.Round(preforma.SecaoPf * 100f / procTubo.SecaoExtrudado, 1);
                    }
                }
            }

            return(result);
        }
Example #17
0
        public static int CodPreformaIdeal(ProcTubo procTubo)     // W
        {
            int result = 0;

            if (procTubo.Cadastro != "--")
            {
                if (7359f / procTubo.SecaoExtrudado <= procTubo.RrMaxResina)
                {
                    result = 5;
                }
                else
                {
                    if (4533f / procTubo.SecaoExtrudado <= procTubo.RrMaxResina)
                    {
                        result = 4;
                    }
                    else
                    {
                        if (2543f / procTubo.SecaoExtrudado <= procTubo.RrMaxResina)
                        {
                            result = 3;
                        }
                        else
                        {
                            if (904f / procTubo.SecaoExtrudado <= procTubo.RrMaxResina)
                            {
                                result = 2;
                            }
                            else
                            {
                                result = 1;
                            }
                        }
                    }
                }
            }

            return(result);
        }
Example #18
0
 public static float CustoTotalRsM(ProcTubo procTubo)      // BD
 {
     return(procTubo.CustoDiretoTotalRsM + procTubo.CustoIndiretoRsM);
 }
Example #19
0
 public static float CustoDiretoTotalRsM(ProcTubo procTubo)      // BB
 {
     return(procTubo.CustoPtfeRsM + procTubo.CustoAditivosRsM + procTubo.CustoLubrifRsM + procTubo.CustoEmbalRsM + procTubo.CustoModRsM);
 }
Example #20
0
        public static float VsintMMin(ProcTubo procTubo)        // AG
        {
            float intermidiate = procTubo.Sinterizado ? 1 : 2;

            return((float)Math.Round(0.7862f * Math.Pow(procTubo.PerimSecaoExtrud, 0.9191f) * intermidiate, 1));
        }
Example #21
0
 public static float VSintResultante(ProcTubo procTubo)      // AI
 {
     return(procTubo.VsintMMin * procTubo.FatorMultiplVelSint);
 }
Example #22
0
 public static float SecaoExtrudado(ProcTubo procTubo)
 {
     return((procTubo.BicoIdeal * procTubo.BicoIdeal - procTubo.MandrilIdeal * procTubo.MandrilIdeal) * (float)Math.PI / 4f);
 }
Example #23
0
 public static int QtPf(ProcTubo procTubo)       // AA
 {
     return((int)Math.Ceiling(procTubo.QtPCusto / procTubo.LanceSinterizado));
 }