@Override public int estimateOperationTimeConsumption(EntityTreeNode operationComponent, BigDecimal plannedQuantity, Entity productionLine) { return estimateOperationTimeConsumption(operationComponent, plannedQuantity, true, true, productionLine); } }
@Override public Map<Entity, Integer> estimateOperationTimeConsumptions(final Entity entity, final BigDecimal plannedQuantity, final boolean includeTpz, final boolean includeAdditionalTime, final Entity productionLine) { return estimateOperationTimeConsumptions(entity, plannedQuantity, includeTpz, includeAdditionalTime, productionLine, false); }
private void evaluateTimes(final Map<Entity, Integer> operationDurations, final Entity operationComponent, final boolean includeTpz, final boolean includeAdditionalTime, final Map<Long, BigDecimal> operationRuns, final Entity productionLine, final boolean maxForWorkstation) { int duration = evaluateSingleOperationTime(operationComponent, includeTpz, includeAdditionalTime, operationRuns, productionLine, maxForWorkstation); operationDurations.put(operationComponent, duration); }
@Override public int evaluateSingleOperationTimeIncludedNextOperationAfterProducedQuantity(Entity operationComponent, final boolean includeTpz, final boolean includeAdditionalTime, final Map<Long, BigDecimal> operationRuns, final Entity productionLine, final boolean maxForWorkstation, final OperationProductComponentWithQuantityContainer productComponentQuantities) { operationComponent = operationComponent.getDataDefinition().get(operationComponent.getId()); BigDecimal cycles = BigDecimal.ONE; BigDecimal nextOperationAfterProducedQuantity = BigDecimalUtils.convertNullToZero(operationComponent .getDecimalField("nextOperationAfterProducedQuantity")); BigDecimal productComponentQuantity = productComponentQuantities.get(getOutputProduct(operationComponent)); Entity technologyOperationComponent = getTechnologyOperationComponent(operationComponent); if (nextOperationAfterProducedQuantity.compareTo(productComponentQuantity) != 1) { cycles = getQuantityCyclesNeededToProducedNextOperationAfterProducedQuantity(technologyOperationComponent, nextOperationAfterProducedQuantity); } else { cycles = operationRuns.get(technologyOperationComponent.getId()); } return evaluateOperationDurationOutOfCycles(cycles, operationComponent, productionLine, maxForWorkstation, includeTpz, includeAdditionalTime); }
private int evaluateOperationTime(final Entity order, final Entity operationComponent, final boolean includeTpz, final boolean includeAdditionalTime, final Map<Long, BigDecimal> operationRuns, final Entity productionLine, final boolean maxForWorkstation, final OperationProductComponentWithQuantityContainer productComponentQuantities) { int operationTime = evaluateSingleOperationTime(operationComponent, includeTpz, includeAdditionalTime, operationRuns, productionLine, maxForWorkstation); int offset = 0; List<Entity> childs = Lists.newArrayList(operationComponent.getHasManyField("children")); for (Entity child : childs) { int childTime = evaluateOperationTime(order, child, includeTpz, includeAdditionalTime, operationRuns, productionLine, maxForWorkstation, productComponentQuantities); if ("02specified".equals(child.getStringField("nextOperationAfterProducedType"))) { int childTimeTotal = evaluateSingleOperationTime(child, includeTpz, includeAdditionalTime, operationRuns, productionLine, true); int childTimeForQuantity = evaluateSingleOperationTimeIncludedNextOperationAfterProducedQuantity(child, includeTpz, false, operationRuns, productionLine, true, productComponentQuantities); int difference = childTimeTotal - childTimeForQuantity; childTime -= difference; } if (childTime > offset) { offset = childTime; } } Entity operCompTimeCalculation = operationWorkTimeService.createOrGetOperCompTimeCalculation(order, operationComponent); if (operCompTimeCalculation != null) { operCompTimeCalculation.setField(OperCompTimeCalculationsFields.OPERATION_OFF_SET, offset); operCompTimeCalculation.setField(OperCompTimeCalculationsFields.EFFECTIVE_OPERATION_REALIZATION_TIME, operationTime); operCompTimeCalculation.getDataDefinition().save(operCompTimeCalculation); } return offset + operationTime; }
@Override public int evaluateOperationDurationOutOfCycles(final BigDecimal cycles, final Entity operationComponent, final Entity productionLine, final boolean maxForWorkstation, final boolean includeTpz, final boolean includeAdditionalTime) { boolean isTjDivisable = operationComponent.getBooleanField("isTjDivisible"); Integer workstationsCount = retrieveWorkstationTypesCount(operationComponent, productionLine); BigDecimal cyclesPerOperation = cycles; if (maxForWorkstation) { cyclesPerOperation = cycles.divide(BigDecimal.valueOf(workstationsCount), numberService.getMathContext()); if (!isTjDivisable) { cyclesPerOperation = cyclesPerOperation.setScale(0, RoundingMode.CEILING); } } int tj = getIntegerValue(operationComponent.getField("tj")); int operationTime = cyclesPerOperation.multiply(BigDecimal.valueOf(tj), numberService.getMathContext()).intValue(); if (includeTpz) { int tpz = getIntegerValue(operationComponent.getField("tpz")); operationTime += (maxForWorkstation ? tpz : (tpz * workstationsCount)); } if (includeAdditionalTime) { int additionalTime = getIntegerValue(operationComponent.getField("timeNextOperation")); operationTime += (maxForWorkstation ? additionalTime : (additionalTime * workstationsCount)); } return operationTime; }
@Override @Transactional public int estimateMaxOperationTimeConsumptionForWorkstation(final Entity order, final EntityTreeNode operationComponent, final BigDecimal plannedQuantity, final boolean includeTpz, final boolean includeAdditionalTime, final Entity productionLine) { Entity technology = operationComponent.getBelongsToField(TECHNOLOGY); Map<Long, BigDecimal> operationRunsFromProductionQuantities = Maps.newHashMap(); OperationProductComponentWithQuantityContainer productComponentQuantities = productQuantitiesService .getProductComponentQuantities(technology, plannedQuantity, operationRunsFromProductionQuantities); return evaluateOperationTime(order, operationComponent, includeTpz, includeAdditionalTime, operationRunsFromProductionQuantities, productionLine, true, productComponentQuantities); }
private BigDecimal getQuantityCyclesNeededToProducedNextOperationAfterProducedQuantity(final Entity operationComponent, final BigDecimal nextOperationAfterProducedQuantity) { MathContext mc = numberService.getMathContext(); Entity technology = operationComponent.getBelongsToField("technology"); Map<Long, BigDecimal> operationRunsFromProductionQuantities = Maps.newHashMap(); OperationProductComponentWithQuantityContainer productQuantities = productQuantitiesService .getProductComponentQuantities(technology, BigDecimal.ONE, operationRunsFromProductionQuantities); BigDecimal operationsRunsForOneMainProduct = operationRunsFromProductionQuantities.get(operationComponent.getId()); BigDecimal quantityOutputProductProduced = productQuantities.get(getOutputProduct(operationComponent)); BigDecimal cycles = operationsRunsForOneMainProduct.multiply(nextOperationAfterProducedQuantity, mc).divide( quantityOutputProductProduced, mc); return numberService.setScaleWithDefaultMathContext(cycles); }
private Integer retrieveWorkstationTypesCount(final Entity operationComponent, final Entity productionLine) { if (StringUtils.isEmpty(operationComponent.getBelongsToField(TechnologyOperationComponentFields.TECHNOLOGY) .getStringField(TechnologyFields.TECHNOLOGY_TYPE))) { if (parameterService.getParameter().getBooleanField("workstationsQuantityFromProductionLine")) { return productionLinesService.getWorkstationTypesCount(operationComponent, productionLine); } else { return getIntegerValue(operationComponent .getIntegerField(TechnologyOperationComponentFields.QUANTITY_OF_WORKSTATIONS)); } } else { return getIntegerValue(operationComponent .getIntegerField(TechnologyOperationComponentFields.QUANTITY_OF_WORKSTATIONS)); } }
private Map<Entity, Integer> estimateOperationTimeConsumptions(final Entity entity, final BigDecimal plannedQuantity, final boolean includeTpz, final boolean includeAdditionalTime, final Entity productionLine, final boolean maxForWorkstation) { Map<Entity, Integer> operationDurations = new HashMap<Entity, Integer>(); String entityType = entity.getDataDefinition().getName(); Entity technology; List<Entity> operationComponents; if (TechnologiesConstants.MODEL_TECHNOLOGY.equals(entityType)) { technology = entity; operationComponents = technology.getTreeField(TechnologyFields.OPERATION_COMPONENTS); } else if (L_ORDER.equals(entityType)) { technology = entity.getBelongsToField(TECHNOLOGY); operationComponents = technology.getTreeField(TechnologyFields.OPERATION_COMPONENTS); } else { throw new IllegalStateException("Entity has to be either order or technology"); } Map<Long, BigDecimal> operationRunsFromProductionQuantities = Maps.newHashMap(); productQuantitiesService .getProductComponentQuantities(technology, plannedQuantity, operationRunsFromProductionQuantities); for (Entity operationComponent : operationComponents) { evaluateTimes(operationDurations, operationComponent, includeTpz, includeAdditionalTime, operationRunsFromProductionQuantities, productionLine, maxForWorkstation); } return operationDurations; }
@Override public int evaluateSingleOperationTime(Entity operationComponent, final boolean includeTpz, final boolean includeAdditionalTime, final Map<Long, BigDecimal> operationRuns, final Entity productionLine, final boolean maxForWorkstation) { operationComponent = operationComponent.getDataDefinition().get(operationComponent.getId()); BigDecimal cycles = operationRuns.get(operationComponent.getId()); if (cycles == null) { Map<Long, BigDecimal> operationRunsFromProductionQuantities = Maps.newHashMap(); OperationProductComponentWithQuantityContainer productComponentQuantities = productQuantitiesService .getProductComponentQuantities(operationComponent .getBelongsToField(TechnologyOperationComponentFields.TECHNOLOGY), new BigDecimal("56", numberService.getMathContext()), operationRunsFromProductionQuantities); cycles = operationRunsFromProductionQuantities.get(operationComponent.getId()); } return evaluateOperationDurationOutOfCycles(cycles, operationComponent, productionLine, maxForWorkstation, includeTpz, includeAdditionalTime); }
@Override @Transactional public int estimateOperationTimeConsumption(final EntityTreeNode operationComponent, final BigDecimal plannedQuantity, final boolean includeTpz, final boolean includeAdditionalTime, final Entity productionLine) { Entity technology = operationComponent.getBelongsToField(TECHNOLOGY); Map<Long, BigDecimal> operationRunsFromProductionQuantities = Maps.newHashMap(); OperationProductComponentWithQuantityContainer productComponentQuantities = productQuantitiesService .getProductComponentQuantities(technology, plannedQuantity, operationRunsFromProductionQuantities); return evaluateOperationTime(null, operationComponent, includeTpz, includeAdditionalTime, operationRunsFromProductionQuantities, productionLine, false, productComponentQuantities); }
@Override public Map<Entity, Integer> estimateMaxOperationTimeConsumptionsForWorkstations(final Entity entity, final BigDecimal plannedQuantity, final boolean includeTpz, final boolean includeAdditionalTime, final Entity productionLine) { return estimateOperationTimeConsumptions(entity, plannedQuantity, includeTpz, includeAdditionalTime, productionLine, true); }