Java Solver类代码示例

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
/**
 * Return new or cached score only solver. Detect changes to the rule list
 * and re-create the solver in that case.
 *
 * @param customDrlFiles the list of user provided DRL files
 * @return score only solver
 */
public static Solver getScoreOnlySolver(List<Path> customDrlFiles) {
    Set<Path> changeDetector = new HashSet<>(customDrlFiles);
    changeDetector.retainAll(recordedCustomDrlFiles);

    if (scoreOnlySolver != null
            && customDrlFiles.size() == changeDetector.size()
            && recordedCustomDrlFiles.size() == changeDetector.size()) {
        return scoreOnlySolver;
    }

    SolverFactory solverFactory =
            SolverFactory.createFromXmlResource("org/ovirt/optimizer/solver/rules/scoreonly.xml");
    addCustomDrlFiles(solverFactory.getSolverConfig().getScoreDirectorFactoryConfig(), customDrlFiles);
    scoreOnlySolver = solverFactory.buildSolver();
    recordedCustomDrlFiles = customDrlFiles;
    return scoreOnlySolver;
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
/**
 * Recompute solution's score and log all rules that affected it (in debug mode)
 * This method uses new score director from the passed solver
 *
 * @param solver
 * @param solution
 */
public static void recomputeScoreUsingScoreDirector(Solver solver, OptimalDistributionStepsSolution solution) {
    ScoreDirector director = solver.getScoreDirectorFactory().buildScoreDirector();
    director.setWorkingSolution(solution);
    Score score = director.calculateScore();

    for (ConstraintMatchTotal constraintMatchTotal : director.getConstraintMatchTotals()) {
        String constraintName = constraintMatchTotal.getConstraintName();
        Number weightTotal = constraintMatchTotal.getWeightTotalAsNumber();
        for (ConstraintMatch constraintMatch : constraintMatchTotal.getConstraintMatchSet()) {
            List<Object> justificationList = constraintMatch.getJustificationList();
            Number weight = constraintMatch.getWeightAsNumber();
            log.debug("Constraint match {} with weight {}", constraintMatch, weight);
            for (Object item : justificationList) {
                log.debug("Justified by {}", item);
            }
        }
    }
    log.debug("Final score {}", score);
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    DevoxxImporter devoxxImporter = new DevoxxImporter();
    SolverFactory<Conference> solverFactory = SolverFactory.createFromXmlResource(
            OptaConfPlanner.SOLVER_CONFIG);

    Conference conference = devoxxImporter.importConference(false);
    logger.info("Imported.");

    Solver<Conference> solver = solverFactory.buildSolver();
    conference = solver.solve(conference);
    logger.info("Solved.");

    ConferenceFileIO fileIO = new ConferenceFileIO();
    File outputFile = File.createTempFile("devoxx2016-", "." + fileIO.getOutputFileExtension());
    fileIO.write(conference, outputFile);
    logger.info("Written.");
    Desktop.getDesktop().open(outputFile);
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
public List<ShiftAssignment> plan() {
    SolverFactory<Solution> solverFactory = SolverFactory.createFromXmlResource("planner/EmployeeRosteringSolverConfig.xml");
    Solver solver = solverFactory.buildSolver();

    EmployeeRoster employeeRoster = new EmployeeRoster();
    employeeRoster.setCode("TEST");
    employeeRoster.setSkillList(employeeRepository.listSkills());
    employeeRoster.setShiftTypeList(shiftRepository.listShiftTypes());
    employeeRoster.setShiftTypeSkillRequirementList(generateShiftTypeSkillRequirements());
    employeeRoster.setPatternList(patternsRepository.listAll());
    employeeRoster.setContractList(contractRepository.listAll());
    employeeRoster.setContractLineList(generateContractLines());
    employeeRoster.setPatternContractLineList(generateContractPatternList());
    employeeRoster.setEmployeeList(employeeRepository.listAll());
    employeeRoster.setSkillProficiencyList(generateSkillProficiency());
    employeeRoster.setShiftDateList(shiftRepository.listShiftDates());
    employeeRoster.setShiftList(shiftRepository.listShifts());
    employeeRoster.setDayOffRequestList(employeeRepository.listDayOffRequests());
    employeeRoster.setDayOnRequestList(employeeRepository.listDayOnRequests());
    employeeRoster.setShiftOffRequestList(employeeRepository.listShiftOffRequests());
    employeeRoster.setShiftOnRequestList(employeeRepository.listShiftOnRequests());
    employeeRoster.setEmployeeRosterParametrization(generateEmployeeRosterInfo());
    employeeRoster.setShiftAssignmentList(generateAssigments());

    employeeRoster = (EmployeeRoster) solver.solve(employeeRoster);
    final HardSoftScore score = employeeRoster.getScore();
    for (ShiftAssignment shiftAssignment : employeeRoster.getShiftAssignmentList()) {
        shiftRepository.createShiftAssignment(shiftAssignment.getShift(), shiftAssignment.getEmployee());
    }
    messageService.informUser(String.format("'%s' score ", score.toString()));

    return shiftRepository.listShiftAssignments();
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
public void terminate(Integer tenantId) {
    Solver<Roster> solver = tenantIdToSolverMap.get(tenantId);
    if (null != solver) {
        solver.terminateEarly();
    }
    else {
        throw new IllegalStateException("The roster with tenantId (" + tenantId
                + ") is not being solved currently.");
    }
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
public void solve(Integer tenantId) {
    logger.info("Scheduling solver for tenantId ({})...", tenantId);
    // No 2 solve() calls of the same dataset in parallel
    tenantIdToSolverStateMap.compute(tenantId, (k, solverStatus) -> {
        if (solverStatus != null && solverStatus != SolverStatus.TERMINATED) {
            throw new IllegalStateException("The roster with tenantId (" + tenantId
                    + ") is already solving with solverStatus (" + solverStatus + ").");
        }
        return SolverStatus.SCHEDULED;
    });
    executorService.submit(() -> {
        try {
            Solver<Roster> solver = solverFactory.buildSolver();
            tenantIdToSolverMap.put(tenantId, solver);
            solver.addEventListener(event -> {
                if (event.isEveryProblemFactChangeProcessed()) {
                    logger.info("  New best solution found for tenantId ({}).", tenantId);
                    Roster newBestRoster = event.getNewBestSolution();
                    // TODO if this throws an OptimisticLockingException, does it kill the solver?
                    rosterRestService.updateShiftsOfRoster(newBestRoster);
                }
            });
            Roster roster = rosterRestService.buildRoster(tenantId);
            try {
                tenantIdToSolverStateMap.put(tenantId, SolverStatus.SOLVING);
                // TODO No need to store the returned roster because the SolverEventListener already does it?
                solver.solve(roster);
            } finally {
                tenantIdToSolverMap.remove(tenantId);
                tenantIdToSolverStateMap.put(tenantId, SolverStatus.TERMINATED);
            }
        } catch (Throwable e) {
            // TODO handle errors through Thread'sExceptionHandler
            logger.error("Error solving for tenantId (" + tenantId + ").", e);
        }
    });
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
public String getShortStatus() {
    Solver<ConferenceData> solver = this.solver;
    String status = solver == null || !solver.isSolving() ? "idle" : "solving";
    if (solver != null) {
        status += ", best score " + solver.getBestScore();
    }
    return status;
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
public String describeBest() {
    Solver<ConferenceData> solver = this.solver;
    if (solver == null) {
        return "";
    }
    ConferenceData currentBest = solver.getBestSolution();
    if (currentBest == prevBest) {
        return prevBestDescr;
    }
    prevBest = currentBest;
    currentBest.sort();

    StringWriter sw = new StringWriter();

    ScoreDirector<ConferenceData> scorer = solver.getScoreDirectorFactory().buildScoreDirector();
    scorer.setWorkingSolution(currentBest);
    Collection<ConstraintMatchTotal> totals = scorer.getConstraintMatchTotals();
    Map<Object, Indictment> map = scorer.getIndictmentMap();

    sw.append("<html><body style='font-family:monospace'>");
    for (ConstraintMatchTotal total : totals) {
        sw.append(String.valueOf(total.getScoreTotal())).append("\t").append(total.getConstraintName()).append("<br>");
    }
    sw.append("<br>");
    currentBest.print(sw, map);
    sw.append("</body></html>");
    prevBestDescr = sw.toString();
    return prevBestDescr;
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
@POST
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public ProblemSolution solveProblem(ProblemDescription problemDescription) {
    logger.info("Received request to route: " + problemDescription);
    SolverFactory solverFactory = SolverFactory.createFromXmlResource(SOLVER_CONFIG);
    Solver solver = solverFactory.buildSolver();
    RoutingSolution routingSolution = problemDescription.createEmptyRoutingSolution();
    solver.solve(routingSolution);
    return ProblemSolution.create((RoutingSolution) solver.getBestSolution());
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
@Override
public void run() {
    SolverFactory sF = SolverFactory.createFromXmlResource("solver/tabuSearch_solverConfig.xml");
    Solver solver = sF.buildSolver();
    AlocacaoHorario bestSolution;

    solver.addEventListener(event -> {
        if (event.isEveryProblemFactChangeProcessed()) {
            AlocacaoHorario newBestSolution;
            System.out.println("Encontrou nova solução.");

            newBestSolution = (AlocacaoHorario) event.getNewBestSolution();

            logarSolucao(newBestSolution);

            listenner.update(Resolvedor.this, event.getNewBestSolution());
        }
    });

    solver.solve(alocacaoHorario);

    bestSolution = (AlocacaoHorario) solver.getBestSolution();

    logarSolucao(bestSolution);

    listenner.update(this, bestSolution);
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
private void populateResult(Exchange exchange, Solver solver) {
    exchange.getIn().setBody(solver.getBestSolution());
    exchange.getIn().setHeader(OptaPlannerConstants.TIME_SPENT, solver.getTimeMillisSpent());
    exchange.getIn().setHeader(OptaPlannerConstants.IS_EVERY_PROBLEM_FACT_CHANGE_PROCESSED, solver.isEveryProblemFactChangeProcessed());
    exchange.getIn().setHeader(OptaPlannerConstants.IS_TERMINATE_EARLY, solver.isTerminateEarly());
    exchange.getIn().setHeader(OptaPlannerConstants.IS_SOLVING, solver.isSolving());
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
protected Solver getOrCreateSolver(String solverId) throws Exception {
    synchronized (SOLVERS) {
        Solver solver = SOLVERS.get(solverId);
        if (solver == null) {
            solver = createSolver();
            SOLVERS.put(solverId, solver);
        }
        return solver;
    }
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
@Override
protected void doStop() throws Exception {
    synchronized (SOLVERS) {
        for (Solver solver : SOLVERS.values()) {
            solver.terminateEarly();
            SOLVERS.remove(solver);
        }
    }
    super.doStop();
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    System.setProperty("logback.level.org.optaplanner", "info"); // don't waste time logging too much

    // Build the Solver
    // TODO cli arg
    SolverFactory<ReindeerRoutingSolution> solverFactory = SolverFactory.createFromXmlResource(SOLVER_CONFIG);
    final Solver<ReindeerRoutingSolution> solver = solverFactory.buildSolver();

    // Load the problem
    final ReindeerRoutingSolution unsolvedReindeerRoutingSolution = (ReindeerRoutingSolution) (new ReindeerRoutingImporter().readSolution(new File("data/sss/import/gifts.csv")));

    // Solve the problem in the background
    System.out.println("OptaPlanner is working hard on your problem. Press any key to stop.");
    Runnable solving = new Runnable() {
        @Override
        public void run() {
            solver.solve(unsolvedReindeerRoutingSolution);
        }
    };
    E.submit(solving);

    // wait for the user to terminate
    System.in.read();
    System.out.println("OptaPlanner will now terminate.");

    // terminate on keypress and write the solution
    new ReindeerRoutingExporter().writeSolution(solver.getBestSolution(), new File("data/sss/solved/solution.csv")); // TODO cli arg
    System.out.println("Solution safely stored.");
    solver.terminateEarly();
    E.shutdownNow();
}
 

import org.optaplanner.core.api.solver.Solver; //导入依赖的package包/类
/**
 * This function returns the best solution to the problem.
 *
 * @return the state of a cluster after solving the placement problem
 */
public ClusterState getBestSolution() {
    Solver solver = vmPlacementSolver.buildSolver();
    solver.setPlanningProblem(getInitialState());
    solver.solve();
    ClusterState result = (ClusterState) solver.getBestSolution();
    cleanThreadLocals(); // to avoid memory leaks
    return result;
}