All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.drools.planner.examples.pas.domain.PatientAdmissionSchedule Maven / Gradle / Ivy

Go to download

Drools Planner optimizes automated planning by combining metaheuristic search algorithms with rule engine powered score calculation. This is the drools-planner-examples module which contains examples on how to use Drools Planner.

There is a newer version: 6.0.0.Alpha9
Show newest version
/*
 * Copyright 2010 JBoss Inc
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.drools.planner.examples.pas.domain;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.drools.planner.api.domain.solution.PlanningEntityCollectionProperty;
import org.drools.planner.core.score.buildin.hardandsoft.HardAndSoftScore;
import org.drools.planner.core.solution.Solution;
import org.drools.planner.examples.common.domain.AbstractPersistable;
import org.drools.planner.examples.pas.domain.solver.AdmissionPartConflict;

@XStreamAlias("PatientAdmissionSchedule")
public class PatientAdmissionSchedule extends AbstractPersistable implements Solution {

    private List specialismList;
    private List equipmentList;
    private List departmentList;
    private List departmentSpecialismList;
    private List roomList;
    private List roomSpecialismList;
    private List roomEquipmentList;
    private List bedList;
    private List nightList;
    private List patientList;
    private List admissionPartList;
    private List requiredPatientEquipmentList;
    private List preferredPatientEquipmentList;

    private List bedDesignationList;

    private HardAndSoftScore score;

    public List getSpecialismList() {
        return specialismList;
    }

    public void setSpecialismList(List specialismList) {
        this.specialismList = specialismList;
    }

    public List getEquipmentList() {
        return equipmentList;
    }

    public void setEquipmentList(List equipmentList) {
        this.equipmentList = equipmentList;
    }

    public List getDepartmentList() {
        return departmentList;
    }

    public void setDepartmentList(List departmentList) {
        this.departmentList = departmentList;
    }

    public List getDepartmentSpecialismList() {
        return departmentSpecialismList;
    }

    public void setDepartmentSpecialismList(List departmentSpecialismList) {
        this.departmentSpecialismList = departmentSpecialismList;
    }

    public List getRoomList() {
        return roomList;
    }

    public void setRoomList(List roomList) {
        this.roomList = roomList;
    }

    public List getRoomSpecialismList() {
        return roomSpecialismList;
    }

    public void setRoomSpecialismList(List roomSpecialismList) {
        this.roomSpecialismList = roomSpecialismList;
    }

    public List getRoomEquipmentList() {
        return roomEquipmentList;
    }

    public void setRoomEquipmentList(List roomEquipmentList) {
        this.roomEquipmentList = roomEquipmentList;
    }

    public List getBedList() {
        return bedList;
    }

    public void setBedList(List bedList) {
        this.bedList = bedList;
    }

    public List getNightList() {
        return nightList;
    }

    public void setNightList(List nightList) {
        this.nightList = nightList;
    }

    public List getPatientList() {
        return patientList;
    }

    public void setPatientList(List patientList) {
        this.patientList = patientList;
    }

    public List getAdmissionPartList() {
        return admissionPartList;
    }

    public void setAdmissionPartList(List admissionPartList) {
        this.admissionPartList = admissionPartList;
    }

    public List getRequiredPatientEquipmentList() {
        return requiredPatientEquipmentList;
    }

    public void setRequiredPatientEquipmentList(List requiredPatientEquipmentList) {
        this.requiredPatientEquipmentList = requiredPatientEquipmentList;
    }

    public List getPreferredPatientEquipmentList() {
        return preferredPatientEquipmentList;
    }

    public void setPreferredPatientEquipmentList(List preferredPatientEquipmentList) {
        this.preferredPatientEquipmentList = preferredPatientEquipmentList;
    }

    @PlanningEntityCollectionProperty
    public List getBedDesignationList() {
        return bedDesignationList;
    }

    public void setBedDesignationList(List bedDesignationList) {
        this.bedDesignationList = bedDesignationList;
    }

    public HardAndSoftScore getScore() {
        return score;
    }

    public void setScore(HardAndSoftScore score) {
        this.score = score;
    }

    // ************************************************************************
    // Complex methods
    // ************************************************************************

    public Collection getProblemFacts() {
        List facts = new ArrayList();
        facts.addAll(specialismList);
        facts.addAll(equipmentList);
        facts.addAll(departmentList);
        facts.addAll(departmentSpecialismList);
        facts.addAll(roomList);
        facts.addAll(roomSpecialismList);
        facts.addAll(roomEquipmentList);
        facts.addAll(bedList);
        facts.addAll(nightList);
        facts.addAll(patientList);
        facts.addAll(admissionPartList);
        facts.addAll(requiredPatientEquipmentList);
        facts.addAll(preferredPatientEquipmentList);
        facts.addAll(calculateAdmissionPartConflictList());
//        facts.addAll(calculateAdmissionPartSpecialismMissingInRoomList());
        // Do not add the planning entity's (bedDesignationList) because that will be done automatically
        return facts;
    }

    private List calculateAdmissionPartConflictList() {
        List admissionPartConflictList = new ArrayList();
        for (AdmissionPart leftAdmissionPart : admissionPartList) {
            for (AdmissionPart rightAdmissionPart : admissionPartList) {
                if (leftAdmissionPart.getId() < rightAdmissionPart.getId()) {
                    int sameNightCount = leftAdmissionPart.calculateSameNightCount(rightAdmissionPart);
                    if (sameNightCount > 0) {
                        admissionPartConflictList.add(new AdmissionPartConflict(
                                leftAdmissionPart, rightAdmissionPart, sameNightCount));
                    }
                }
            }
        }
        return admissionPartConflictList;
    }

//    private List calculateAdmissionPartSpecialismMissingInRoomList() {
//        List admissionPartSpecialismMissingInRoomList
//                = new ArrayList();
//        for (AdmissionPart admissionPart : admissionPartList) {
//            if (admissionPart.getSpecialism() != null) {
//                for (Room room : roomList) {
//                    int mininumPriority = Integer.MAX_VALUE;
//                    for (RoomSpecialism roomSpecialism : room.getRoomSpecialismList()) {
//                        if (roomSpecialism.getSpecialism().equals(admissionPart.getSpecialism())) {
//                            mininumPriority = Math.min(mininumPriority, roomSpecialism.getPriority());
//                        }
//                    }
//                    int weight = (mininumPriority == Integer.MAX_VALUE) ? 2 : mininumPriority - 1;
//                    if (weight > 0) {
//                        admissionPartSpecialismMissingInRoomList.add(
//                                new AdmissionPartSpecialismMissingInRoom(admissionPart, room, mininumPriority));
//                    }
//                }
//            }
//        }
//        return admissionPartSpecialismMissingInRoomList;
//    }

    /**
     * Clone will only deep copy the {@link #bedDesignationList}.
     */
    public PatientAdmissionSchedule cloneSolution() {
        PatientAdmissionSchedule clone = new PatientAdmissionSchedule();
        clone.id = id;
        clone.specialismList = specialismList;
        clone.equipmentList = equipmentList;
        clone.departmentList = departmentList;
        clone.departmentSpecialismList = departmentSpecialismList;
        clone.roomList = roomList;
        clone.roomSpecialismList = roomSpecialismList;
        clone.roomEquipmentList = roomEquipmentList;
        clone.bedList = bedList;
        clone.nightList = nightList;
        clone.patientList = patientList;
        clone.admissionPartList = admissionPartList;
        clone.requiredPatientEquipmentList = requiredPatientEquipmentList;
        clone.preferredPatientEquipmentList = preferredPatientEquipmentList;
        List clonedBedDesignationList = new ArrayList(bedDesignationList.size());
        for (BedDesignation bedDesignation : bedDesignationList) {
            BedDesignation clonedBedDesignation = bedDesignation.clone();
            clonedBedDesignationList.add(clonedBedDesignation);
        }
        clone.bedDesignationList = clonedBedDesignationList;
        clone.score = score;
        return clone;
    }

    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (id == null || !(o instanceof PatientAdmissionSchedule)) {
            return false;
        } else {
            PatientAdmissionSchedule other = (PatientAdmissionSchedule) o;
            if (bedDesignationList.size() != other.bedDesignationList.size()) {
                return false;
            }
            for (Iterator it = bedDesignationList.iterator(), otherIt = other.bedDesignationList.iterator(); it.hasNext();) {
                BedDesignation bedDesignation = it.next();
                BedDesignation otherBedDesignation = otherIt.next();
                // Notice: we don't use equals()
                if (!bedDesignation.solutionEquals(otherBedDesignation)) {
                    return false;
                }
            }
            return true;
        }
    }

    public int hashCode() {
        HashCodeBuilder hashCodeBuilder = new HashCodeBuilder();
        for (BedDesignation bedDesignation : bedDesignationList) {
            // Notice: we don't use hashCode()
            hashCodeBuilder.append(bedDesignation.solutionHashCode());
        }
        return hashCodeBuilder.toHashCode();
    }

}