Example 1 with Constraint
use of org.cpsolver.ifs.model.Constraint in project cpsolver by UniTime.
the class StudentSectioningXMLLoader method loadStudents.
/**
* Load students
* @param studentsEl students element
* @param offeringTable offering table
* @param courseTable course table
*/
protected void loadStudents(Element studentsEl, Map<Long, Offering> offeringTable, Map<Long, Course> courseTable) {
List<Enrollment> bestEnrollments = new ArrayList<Enrollment>();
List<Enrollment> currentEnrollments = new ArrayList<Enrollment>();
for (Iterator<?> i = studentsEl.elementIterator("student"); i.hasNext(); ) {
Element studentEl = (Element) i.next();
Student student = loadStudent(studentEl, offeringTable);
if (iStudentFilter != null && !iStudentFilter.accept(student))
continue;
for (Iterator<?> j = studentEl.elementIterator(); j.hasNext(); ) {
Element requestEl = (Element) j.next();
Request request = loadRequest(requestEl, student, offeringTable, courseTable);
if (request == null)
continue;
Element initialEl = requestEl.element("initial");
if (iLoadInitial && initialEl != null) {
Enrollment enrollment = loadEnrollment(initialEl, request);
if (enrollment != null)
request.setInitialAssignment(enrollment);
}
Element currentEl = requestEl.element("current");
if (iLoadCurrent && currentEl != null) {
Enrollment enrollment = loadEnrollment(currentEl, request);
if (enrollment != null)
currentEnrollments.add(enrollment);
}
Element bestEl = requestEl.element("best");
if (iLoadBest && bestEl != null) {
Enrollment enrollment = loadEnrollment(bestEl, request);
if (enrollment != null)
bestEnrollments.add(enrollment);
}
}
getModel().addStudent(student);
}
if (!bestEnrollments.isEmpty()) {
// Enrollments with a reservation must go first
for (Enrollment enrollment : bestEnrollments) {
if (enrollment.getReservation() == null)
continue;
if (!enrollment.getStudent().isAvailable(enrollment)) {
sLogger.warn("Enrollment " + enrollment + " is conflicting: student not available.");
continue;
}
Map<Constraint<Request, Enrollment>, Set<Enrollment>> conflicts = getModel().conflictConstraints(getAssignment(), enrollment);
if (conflicts.isEmpty())
getAssignment().assign(0, enrollment);
else
sLogger.warn("Enrollment " + enrollment + " conflicts with " + conflicts);
}
for (Enrollment enrollment : bestEnrollments) {
if (enrollment.getReservation() != null)
continue;
if (!enrollment.getStudent().isAvailable(enrollment)) {
sLogger.warn("Enrollment " + enrollment + " is conflicting: student not available.");
continue;
}
Map<Constraint<Request, Enrollment>, Set<Enrollment>> conflicts = getModel().conflictConstraints(getAssignment(), enrollment);
if (conflicts.isEmpty())
getAssignment().assign(0, enrollment);
else
sLogger.warn("Enrollment " + enrollment + " conflicts with " + conflicts);
}
getModel().saveBest(getAssignment());
}
if (!currentEnrollments.isEmpty()) {
for (Request request : getModel().variables()) getAssignment().unassign(0, request);
// Enrollments with a reservation must go first
for (Enrollment enrollment : currentEnrollments) {
if (enrollment.getReservation() == null)
continue;
if (!enrollment.getStudent().isAvailable(enrollment)) {
sLogger.warn("Enrollment " + enrollment + " is conflicting: student not available.");
continue;
}
Map<Constraint<Request, Enrollment>, Set<Enrollment>> conflicts = getModel().conflictConstraints(getAssignment(), enrollment);
if (conflicts.isEmpty())
getAssignment().assign(0, enrollment);
else
sLogger.warn("Enrollment " + enrollment + " conflicts with " + conflicts);
}
for (Enrollment enrollment : currentEnrollments) {
if (enrollment.getReservation() != null)
continue;
if (!enrollment.getStudent().isAvailable(enrollment)) {
sLogger.warn("Enrollment " + enrollment + " is conflicting: student not available.");
continue;
}
Map<Constraint<Request, Enrollment>, Set<Enrollment>> conflicts = getModel().conflictConstraints(getAssignment(), enrollment);
if (conflicts.isEmpty())
getAssignment().assign(0, enrollment);
else
sLogger.warn("Enrollment " + enrollment + " conflicts with " + conflicts);
}
}
}
Also used :
HashSet(java.util.HashSet)
Set(java.util.Set)
BitSet(java.util.BitSet)
Constraint(org.cpsolver.ifs.model.Constraint)
Element(org.dom4j.Element)
ArrayList(java.util.ArrayList)
FreeTimeRequest(org.cpsolver.studentsct.model.FreeTimeRequest)
Request(org.cpsolver.studentsct.model.Request)
CourseRequest(org.cpsolver.studentsct.model.CourseRequest)
Enrollment(org.cpsolver.studentsct.model.Enrollment)
Student(org.cpsolver.studentsct.model.Student)
Example 2 with Constraint
use of org.cpsolver.ifs.model.Constraint in project cpsolver by UniTime.
the class TimetableXMLLoader method doLoad.
protected void doLoad(Solution<Lecture, Placement> currentSolution, Element root) {
if (root.attributeValue("term") != null)
getModel().getProperties().setProperty("Data.Term", root.attributeValue("term"));
if (root.attributeValue("year") != null)
getModel().setYear(Integer.parseInt(root.attributeValue("year")));
else if (root.attributeValue("term") != null)
getModel().setYear(Integer.parseInt(root.attributeValue("term").substring(0, 4)));
if (root.attributeValue("initiative") != null)
getModel().getProperties().setProperty("Data.Initiative", root.attributeValue("initiative"));
if (root.attributeValue("semester") != null && root.attributeValue("year") != null)
getModel().getProperties().setProperty("Data.Term", root.attributeValue("semester") + root.attributeValue("year"));
if (root.attributeValue("session") != null)
getModel().getProperties().setProperty("General.SessionId", root.attributeValue("session"));
if (root.attributeValue("solverGroup") != null)
getModel().getProperties().setProperty("General.SolverGroupId", root.attributeValue("solverGroup"));
String version = root.attributeValue("version");
// Student sectioning considers the whole course (including committed classes), since 2.5
boolean sectionWholeCourse = true;
if (version != null && version.indexOf('.') >= 0) {
int majorVersion = Integer.parseInt(version.substring(0, version.indexOf('.')));
int minorVersion = Integer.parseInt(version.substring(1 + version.indexOf('.')));
sectionWholeCourse = (majorVersion == 2 && minorVersion >= 5) || majorVersion > 2;
}
HashMap<Long, TimeLocation> perts = new HashMap<Long, TimeLocation>();
if (getModel().getProperties().getPropertyInt("MPP.TimePert", 0) > 0) {
int nrChanges = getModel().getProperties().getPropertyInt("MPP.TimePert", 0);
int idx = 0;
for (Iterator<?> i = root.element("perturbations").elementIterator("class"); i.hasNext() && idx < nrChanges; idx++) {
Element pertEl = (Element) i.next();
Long classId = Long.valueOf(pertEl.attributeValue("id"));
TimeLocation tl = new TimeLocation(Integer.parseInt(pertEl.attributeValue("days"), 2), Integer.parseInt(pertEl.attributeValue("start")), Integer.parseInt(pertEl.attributeValue("length")), 0, 0.0, 0, null, null, null, 0);
perts.put(classId, tl);
}
}
iProgress.setPhase("Creating rooms ...", root.element("rooms").elements("room").size());
HashMap<String, Element> roomElements = new HashMap<String, Element>();
HashMap<String, RoomConstraint> roomConstraints = new HashMap<String, RoomConstraint>();
HashMap<Long, List<Lecture>> sameLectures = new HashMap<Long, List<Lecture>>();
for (Iterator<?> i = root.element("rooms").elementIterator("room"); i.hasNext(); ) {
Element roomEl = (Element) i.next();
iProgress.incProgress();
roomElements.put(roomEl.attributeValue("id"), roomEl);
if ("false".equals(roomEl.attributeValue("constraint")))
continue;
RoomSharingModel sharingModel = null;
Element sharingEl = roomEl.element("sharing");
if (sharingEl != null) {
Character freeForAllPrefChar = null;
Element freeForAllEl = sharingEl.element("freeForAll");
if (freeForAllEl != null)
freeForAllPrefChar = freeForAllEl.attributeValue("value", "F").charAt(0);
Character notAvailablePrefChar = null;
Element notAvailableEl = sharingEl.element("notAvailable");
if (notAvailableEl != null)
notAvailablePrefChar = notAvailableEl.attributeValue("value", "X").charAt(0);
String pattern = sharingEl.element("pattern").getText();
int unit = Integer.parseInt(sharingEl.element("pattern").attributeValue("unit", "1"));
Map<Character, Long> departments = new HashMap<Character, Long>();
for (Iterator<?> j = sharingEl.elementIterator("department"); j.hasNext(); ) {
Element deptEl = (Element) j.next();
char value = deptEl.attributeValue("value", String.valueOf((char) ('0' + departments.size()))).charAt(0);
Long id = Long.valueOf(deptEl.attributeValue("id"));
departments.put(value, id);
}
sharingModel = new RoomSharingModel(unit, departments, pattern, freeForAllPrefChar, notAvailablePrefChar);
}
boolean ignoreTooFar = false;
if ("true".equals(roomEl.attributeValue("ignoreTooFar")))
ignoreTooFar = true;
boolean fake = false;
if ("true".equals(roomEl.attributeValue("fake")))
fake = true;
Double posX = null, posY = null;
if (roomEl.attributeValue("location") != null) {
String loc = roomEl.attributeValue("location");
posX = Double.valueOf(loc.substring(0, loc.indexOf(',')));
posY = Double.valueOf(loc.substring(loc.indexOf(',') + 1));
}
boolean discouraged = "true".equals(roomEl.attributeValue("discouraged"));
RoomConstraint constraint = (discouraged ? new DiscouragedRoomConstraint(getModel().getProperties(), Long.valueOf(roomEl.attributeValue("id")), (roomEl.attributeValue("name") != null ? roomEl.attributeValue("name") : "r" + roomEl.attributeValue("id")), (roomEl.attributeValue("building") == null ? null : Long.valueOf(roomEl.attributeValue("building"))), Integer.parseInt(roomEl.attributeValue("capacity")), sharingModel, posX, posY, ignoreTooFar, !fake) : new RoomConstraint(Long.valueOf(roomEl.attributeValue("id")), (roomEl.attributeValue("name") != null ? roomEl.attributeValue("name") : "r" + roomEl.attributeValue("id")), (roomEl.attributeValue("building") == null ? null : Long.valueOf(roomEl.attributeValue("building"))), Integer.parseInt(roomEl.attributeValue("capacity")), sharingModel, posX, posY, ignoreTooFar, !fake));
if (roomEl.attributeValue("type") != null)
constraint.setType(Long.valueOf(roomEl.attributeValue("type")));
getModel().addConstraint(constraint);
roomConstraints.put(roomEl.attributeValue("id"), constraint);
for (Iterator<?> j = roomEl.elementIterator("travel-time"); j.hasNext(); ) {
Element travelTimeEl = (Element) j.next();
getModel().getDistanceMetric().addTravelTime(constraint.getResourceId(), Long.valueOf(travelTimeEl.attributeValue("id")), Integer.valueOf(travelTimeEl.attributeValue("minutes")));
}
}
HashMap<String, InstructorConstraint> instructorConstraints = new HashMap<String, InstructorConstraint>();
if (root.element("instructors") != null) {
for (Iterator<?> i = root.element("instructors").elementIterator("instructor"); i.hasNext(); ) {
Element instructorEl = (Element) i.next();
InstructorConstraint instructorConstraint = null;
if ("true".equalsIgnoreCase(instructorEl.attributeValue("soft", "false"))) {
instructorConstraint = new SoftInstructorConstraint(Long.valueOf(instructorEl.attributeValue("id")), instructorEl.attributeValue("puid"), (instructorEl.attributeValue("name") != null ? instructorEl.attributeValue("name") : "i" + instructorEl.attributeValue("id")), "true".equals(instructorEl.attributeValue("ignDist")));
} else {
instructorConstraint = new InstructorConstraint(Long.valueOf(instructorEl.attributeValue("id")), instructorEl.attributeValue("puid"), (instructorEl.attributeValue("name") != null ? instructorEl.attributeValue("name") : "i" + instructorEl.attributeValue("id")), "true".equals(instructorEl.attributeValue("ignDist")));
}
if (instructorEl.attributeValue("type") != null)
instructorConstraint.setType(Long.valueOf(instructorEl.attributeValue("type")));
instructorConstraints.put(instructorEl.attributeValue("id"), instructorConstraint);
getModel().addConstraint(instructorConstraint);
}
}
HashMap<Long, String> depts = new HashMap<Long, String>();
if (root.element("departments") != null) {
for (Iterator<?> i = root.element("departments").elementIterator("department"); i.hasNext(); ) {
Element deptEl = (Element) i.next();
depts.put(Long.valueOf(deptEl.attributeValue("id")), (deptEl.attributeValue("name") != null ? deptEl.attributeValue("name") : "d" + deptEl.attributeValue("id")));
}
}
HashMap<Long, Configuration> configs = new HashMap<Long, Configuration>();
HashMap<Long, List<Configuration>> alternativeConfigurations = new HashMap<Long, List<Configuration>>();
if (root.element("configurations") != null) {
for (Iterator<?> i = root.element("configurations").elementIterator("config"); i.hasNext(); ) {
Element configEl = (Element) i.next();
Long configId = Long.valueOf(configEl.attributeValue("id"));
int limit = Integer.parseInt(configEl.attributeValue("limit"));
Long offeringId = Long.valueOf(configEl.attributeValue("offering"));
Configuration config = new Configuration(offeringId, configId, limit);
configs.put(configId, config);
List<Configuration> altConfigs = alternativeConfigurations.get(offeringId);
if (altConfigs == null) {
altConfigs = new ArrayList<Configuration>();
alternativeConfigurations.put(offeringId, altConfigs);
}
altConfigs.add(config);
config.setAltConfigurations(altConfigs);
}
}
iProgress.setPhase("Creating variables ...", root.element("classes").elements("class").size());
HashMap<String, Element> classElements = new HashMap<String, Element>();
HashMap<String, Lecture> lectures = new HashMap<String, Lecture>();
HashMap<Lecture, Placement> assignedPlacements = new HashMap<Lecture, Placement>();
HashMap<Lecture, String> parents = new HashMap<Lecture, String>();
int ord = 0;
for (Iterator<?> i1 = root.element("classes").elementIterator("class"); i1.hasNext(); ) {
Element classEl = (Element) i1.next();
Configuration config = null;
if (classEl.attributeValue("config") != null) {
config = configs.get(Long.valueOf(classEl.attributeValue("config")));
}
if (config == null && classEl.attributeValue("offering") != null) {
Long offeringId = Long.valueOf(classEl.attributeValue("offering"));
Long configId = Long.valueOf(classEl.attributeValue("config"));
List<Configuration> altConfigs = alternativeConfigurations.get(offeringId);
if (altConfigs == null) {
altConfigs = new ArrayList<Configuration>();
alternativeConfigurations.put(offeringId, altConfigs);
}
for (Configuration c : altConfigs) {
if (c.getConfigId().equals(configId)) {
config = c;
break;
}
}
if (config == null) {
config = new Configuration(offeringId, configId, -1);
altConfigs.add(config);
config.setAltConfigurations(altConfigs);
configs.put(config.getConfigId(), config);
}
}
DatePattern defaultDatePattern = new DatePattern();
if (classEl.attributeValue("dates") == null) {
int startDay = Integer.parseInt(classEl.attributeValue("startDay", "0"));
int endDay = Integer.parseInt(classEl.attributeValue("endDay", "1"));
defaultDatePattern.setPattern(startDay, endDay);
defaultDatePattern.setName(sDF.format(getDate(getModel().getYear(), startDay)) + "-" + sDF.format(getDate(getModel().getYear(), endDay)));
} else {
defaultDatePattern.setId(classEl.attributeValue("datePattern") == null ? null : Long.valueOf(classEl.attributeValue("datePattern")));
defaultDatePattern.setName(classEl.attributeValue("datePatternName"));
defaultDatePattern.setPattern(classEl.attributeValue("dates"));
}
Hashtable<Long, DatePattern> datePatterns = new Hashtable<Long, TimetableXMLLoader.DatePattern>();
for (Iterator<?> i2 = classEl.elementIterator("date"); i2.hasNext(); ) {
Element dateEl = (Element) i2.next();
Long id = Long.valueOf(dateEl.attributeValue("id"));
datePatterns.put(id, new DatePattern(id, dateEl.attributeValue("name"), dateEl.attributeValue("pattern")));
}
classElements.put(classEl.attributeValue("id"), classEl);
List<InstructorConstraint> ics = new ArrayList<InstructorConstraint>();
for (Iterator<?> i2 = classEl.elementIterator("instructor"); i2.hasNext(); ) {
Element instructorEl = (Element) i2.next();
InstructorConstraint instructorConstraint = instructorConstraints.get(instructorEl.attributeValue("id"));
if (instructorConstraint == null) {
instructorConstraint = new InstructorConstraint(Long.valueOf(instructorEl.attributeValue("id")), instructorEl.attributeValue("puid"), (instructorEl.attributeValue("name") != null ? instructorEl.attributeValue("name") : "i" + instructorEl.attributeValue("id")), "true".equals(instructorEl.attributeValue("ignDist")));
instructorConstraints.put(instructorEl.attributeValue("id"), instructorConstraint);
getModel().addConstraint(instructorConstraint);
}
ics.add(instructorConstraint);
}
List<RoomLocation> roomLocations = new ArrayList<RoomLocation>();
List<RoomConstraint> roomConstraintsThisClass = new ArrayList<RoomConstraint>();
List<RoomLocation> initialRoomLocations = new ArrayList<RoomLocation>();
List<RoomLocation> assignedRoomLocations = new ArrayList<RoomLocation>();
List<RoomLocation> bestRoomLocations = new ArrayList<RoomLocation>();
for (Iterator<?> i2 = classEl.elementIterator("room"); i2.hasNext(); ) {
Element roomLocationEl = (Element) i2.next();
Element roomEl = roomElements.get(roomLocationEl.attributeValue("id"));
RoomConstraint roomConstraint = roomConstraints.get(roomLocationEl.attributeValue("id"));
Long roomId = null;
String roomName = null;
Long bldgId = null;
if (roomConstraint != null) {
roomConstraintsThisClass.add(roomConstraint);
roomId = roomConstraint.getResourceId();
roomName = roomConstraint.getRoomName();
bldgId = roomConstraint.getBuildingId();
} else {
roomId = Long.valueOf(roomEl.attributeValue("id"));
roomName = (roomEl.attributeValue("name") != null ? roomEl.attributeValue("name") : "r" + roomEl.attributeValue("id"));
bldgId = (roomEl.attributeValue("building") == null ? null : Long.valueOf(roomEl.attributeValue("building")));
}
boolean ignoreTooFar = false;
if ("true".equals(roomEl.attributeValue("ignoreTooFar")))
ignoreTooFar = true;
Double posX = null, posY = null;
if (roomEl.attributeValue("location") != null) {
String loc = roomEl.attributeValue("location");
posX = Double.valueOf(loc.substring(0, loc.indexOf(',')));
posY = Double.valueOf(loc.substring(loc.indexOf(',') + 1));
}
RoomLocation rl = new RoomLocation(roomId, roomName, bldgId, Integer.parseInt(roomLocationEl.attributeValue("pref")), Integer.parseInt(roomEl.attributeValue("capacity")), posX, posY, ignoreTooFar, roomConstraint);
if ("true".equals(roomLocationEl.attributeValue("initial")))
initialRoomLocations.add(rl);
if ("true".equals(roomLocationEl.attributeValue("solution")))
assignedRoomLocations.add(rl);
if ("true".equals(roomLocationEl.attributeValue("best")))
bestRoomLocations.add(rl);
roomLocations.add(rl);
}
List<TimeLocation> timeLocations = new ArrayList<TimeLocation>();
TimeLocation initialTimeLocation = null;
TimeLocation assignedTimeLocation = null;
TimeLocation bestTimeLocation = null;
TimeLocation prohibitedTime = perts.get(Long.valueOf(classEl.attributeValue("id")));
for (Iterator<?> i2 = classEl.elementIterator("time"); i2.hasNext(); ) {
Element timeLocationEl = (Element) i2.next();
DatePattern dp = defaultDatePattern;
if (timeLocationEl.attributeValue("date") != null)
dp = datePatterns.get(Long.valueOf(timeLocationEl.attributeValue("date")));
TimeLocation tl = new TimeLocation(Integer.parseInt(timeLocationEl.attributeValue("days"), 2), Integer.parseInt(timeLocationEl.attributeValue("start")), Integer.parseInt(timeLocationEl.attributeValue("length")), (int) Double.parseDouble(timeLocationEl.attributeValue("pref")), Double.parseDouble(timeLocationEl.attributeValue("npref", timeLocationEl.attributeValue("pref"))), Integer.parseInt(timeLocationEl.attributeValue("datePref", "0")), dp.getId(), dp.getName(), dp.getPattern(), Integer.parseInt(timeLocationEl.attributeValue("breakTime") == null ? "-1" : timeLocationEl.attributeValue("breakTime")));
if (tl.getBreakTime() < 0)
tl.setBreakTime(tl.getLength() == 18 ? 15 : 10);
if (timeLocationEl.attributeValue("pattern") != null)
tl.setTimePatternId(Long.valueOf(timeLocationEl.attributeValue("pattern")));
/*
* if (timePatternTransform) tl =
* transformTimePattern(Long.valueOf
* (classEl.attributeValue("id")),tl);
*/
if (prohibitedTime != null && prohibitedTime.getDayCode() == tl.getDayCode() && prohibitedTime.getStartSlot() == tl.getStartSlot() && prohibitedTime.getLength() == tl.getLength()) {
sLogger.info("Time " + tl.getLongName(true) + " is prohibited for class " + classEl.attributeValue("id"));
continue;
}
if ("true".equals(timeLocationEl.attributeValue("solution")))
assignedTimeLocation = tl;
if ("true".equals(timeLocationEl.attributeValue("initial")))
initialTimeLocation = tl;
if ("true".equals(timeLocationEl.attributeValue("best")))
bestTimeLocation = tl;
timeLocations.add(tl);
}
if (timeLocations.isEmpty()) {
sLogger.error(" ERROR: No time.");
continue;
}
int minClassLimit = 0;
int maxClassLimit = 0;
float room2limitRatio = 1.0f;
if (!"true".equals(classEl.attributeValue("committed"))) {
if (classEl.attributeValue("expectedCapacity") != null) {
minClassLimit = maxClassLimit = Integer.parseInt(classEl.attributeValue("expectedCapacity"));
int roomCapacity = Integer.parseInt(classEl.attributeValue("roomCapacity", classEl.attributeValue("expectedCapacity")));
if (minClassLimit == 0)
minClassLimit = maxClassLimit = roomCapacity;
room2limitRatio = (minClassLimit == 0 ? 1.0f : ((float) roomCapacity) / minClassLimit);
} else {
if (classEl.attribute("classLimit") != null) {
minClassLimit = maxClassLimit = Integer.parseInt(classEl.attributeValue("classLimit"));
} else {
minClassLimit = Integer.parseInt(classEl.attributeValue("minClassLimit"));
maxClassLimit = Integer.parseInt(classEl.attributeValue("maxClassLimit"));
}
room2limitRatio = Float.parseFloat(classEl.attributeValue("roomToLimitRatio", "1.0"));
}
}
Lecture lecture = new Lecture(Long.valueOf(classEl.attributeValue("id")), (classEl.attributeValue("solverGroup") != null ? Long.valueOf(classEl.attributeValue("solverGroup")) : null), Long.valueOf(classEl.attributeValue("subpart", classEl.attributeValue("course", "-1"))), (classEl.attributeValue("name") != null ? classEl.attributeValue("name") : "c" + classEl.attributeValue("id")), timeLocations, roomLocations, Integer.parseInt(classEl.attributeValue("nrRooms", roomLocations.isEmpty() ? "0" : "1")), null, minClassLimit, maxClassLimit, room2limitRatio);
lecture.setNote(classEl.attributeValue("note"));
if ("true".equals(classEl.attributeValue("committed")))
lecture.setCommitted(true);
if (!lecture.isCommitted() && classEl.attributeValue("ord") != null)
lecture.setOrd(Integer.parseInt(classEl.attributeValue("ord")));
else
lecture.setOrd(ord++);
lecture.setWeight(Double.parseDouble(classEl.attributeValue("weight", "1.0")));
if (lecture.getNrRooms() > 1)
lecture.setMaxRoomCombinations(Integer.parseInt(classEl.attributeValue("maxRoomCombinations", "-1")));
if (config != null)
lecture.setConfiguration(config);
if (initialTimeLocation != null && initialRoomLocations.size() == lecture.getNrRooms()) {
lecture.setInitialAssignment(new Placement(lecture, initialTimeLocation, initialRoomLocations));
}
if (assignedTimeLocation != null && assignedRoomLocations.size() == lecture.getNrRooms()) {
assignedPlacements.put(lecture, new Placement(lecture, assignedTimeLocation, assignedRoomLocations));
} else if (lecture.getInitialAssignment() != null) {
// assignedPlacements.put(lecture, lecture.getInitialAssignment());
}
if (bestTimeLocation != null && bestRoomLocations.size() == lecture.getNrRooms()) {
lecture.setBestAssignment(new Placement(lecture, bestTimeLocation, bestRoomLocations), 0);
} else if (assignedTimeLocation != null && assignedRoomLocations.size() == lecture.getNrRooms()) {
// lecture.setBestAssignment(assignedPlacements.get(lecture), 0);
}
lectures.put(classEl.attributeValue("id"), lecture);
if (classEl.attributeValue("department") != null)
lecture.setDepartment(Long.valueOf(classEl.attributeValue("department")));
if (classEl.attribute("scheduler") != null)
lecture.setScheduler(Long.valueOf(classEl.attributeValue("scheduler")));
if ((sectionWholeCourse || !lecture.isCommitted()) && classEl.attributeValue("subpart", classEl.attributeValue("course")) != null) {
Long subpartId = Long.valueOf(classEl.attributeValue("subpart", classEl.attributeValue("course")));
List<Lecture> sames = sameLectures.get(subpartId);
if (sames == null) {
sames = new ArrayList<Lecture>();
sameLectures.put(subpartId, sames);
}
sames.add(lecture);
}
String parent = classEl.attributeValue("parent");
if (parent != null)
parents.put(lecture, parent);
getModel().addVariable(lecture);
if (lecture.isCommitted()) {
Placement placement = assignedPlacements.get(lecture);
if (classEl.attribute("assignment") != null)
placement.setAssignmentId(Long.valueOf(classEl.attributeValue("assignment")));
for (InstructorConstraint ic : ics) ic.setNotAvailable(placement);
for (RoomConstraint rc : roomConstraintsThisClass) if (rc.getConstraint())
rc.setNotAvailable(placement);
} else {
for (InstructorConstraint ic : ics) ic.addVariable(lecture);
for (RoomConstraint rc : roomConstraintsThisClass) rc.addVariable(lecture);
}
iProgress.incProgress();
}
for (Map.Entry<Lecture, String> entry : parents.entrySet()) {
Lecture lecture = entry.getKey();
Lecture parent = lectures.get(entry.getValue());
if (parent == null) {
iProgress.warn("Parent class " + entry.getValue() + " does not exists.");
} else {
lecture.setParent(parent);
}
}
iProgress.setPhase("Creating constraints ...", root.element("groupConstraints").elements("constraint").size());
HashMap<String, Element> grConstraintElements = new HashMap<String, Element>();
HashMap<String, Constraint<Lecture, Placement>> groupConstraints = new HashMap<String, Constraint<Lecture, Placement>>();
for (Iterator<?> i1 = root.element("groupConstraints").elementIterator("constraint"); i1.hasNext(); ) {
Element grConstraintEl = (Element) i1.next();
Constraint<Lecture, Placement> c = null;
if ("SPREAD".equals(grConstraintEl.attributeValue("type"))) {
c = new SpreadConstraint(getModel().getProperties(), grConstraintEl.attributeValue("name", "spread"));
} else if ("MIN_ROOM_USE".equals(grConstraintEl.attributeValue("type"))) {
c = new MinimizeNumberOfUsedRoomsConstraint(getModel().getProperties());
} else if ("CLASS_LIMIT".equals(grConstraintEl.attributeValue("type"))) {
if (grConstraintEl.element("parentClass") == null) {
c = new ClassLimitConstraint(Integer.parseInt(grConstraintEl.attributeValue("courseLimit")), grConstraintEl.attributeValue("name", "class-limit"));
} else {
String classId = grConstraintEl.element("parentClass").attributeValue("id");
c = new ClassLimitConstraint(lectures.get(classId), grConstraintEl.attributeValue("name", "class-limit"));
}
if (grConstraintEl.attributeValue("delta") != null)
((ClassLimitConstraint) c).setClassLimitDelta(Integer.parseInt(grConstraintEl.attributeValue("delta")));
} else if ("MIN_GRUSE(10x1h)".equals(grConstraintEl.attributeValue("type"))) {
c = new MinimizeNumberOfUsedGroupsOfTime(getModel().getProperties(), "10x1h", MinimizeNumberOfUsedGroupsOfTime.sGroups10of1h);
} else if ("MIN_GRUSE(5x2h)".equals(grConstraintEl.attributeValue("type"))) {
c = new MinimizeNumberOfUsedGroupsOfTime(getModel().getProperties(), "5x2h", MinimizeNumberOfUsedGroupsOfTime.sGroups5of2h);
} else if ("MIN_GRUSE(3x3h)".equals(grConstraintEl.attributeValue("type"))) {
c = new MinimizeNumberOfUsedGroupsOfTime(getModel().getProperties(), "3x3h", MinimizeNumberOfUsedGroupsOfTime.sGroups3of3h);
} else if ("MIN_GRUSE(2x5h)".equals(grConstraintEl.attributeValue("type"))) {
c = new MinimizeNumberOfUsedGroupsOfTime(getModel().getProperties(), "2x5h", MinimizeNumberOfUsedGroupsOfTime.sGroups2of5h);
} else if (IgnoreStudentConflictsConstraint.REFERENCE.equals(grConstraintEl.attributeValue("type"))) {
c = new IgnoreStudentConflictsConstraint();
} else {
try {
FlexibleConstraintType f = FlexibleConstraintType.valueOf(grConstraintEl.attributeValue("type"));
try {
c = f.create(Long.valueOf(grConstraintEl.attributeValue("id")), grConstraintEl.attributeValue("owner"), grConstraintEl.attributeValue("pref"), grConstraintEl.attributeValue("reference"));
} catch (IllegalArgumentException e) {
iProgress.warn("Failed to create flexible constraint " + grConstraintEl.attributeValue("type") + ": " + e.getMessage(), e);
continue;
}
} catch (IllegalArgumentException e) {
// type did not match, continue with group constraint types
c = new GroupConstraint(Long.valueOf(grConstraintEl.attributeValue("id")), GroupConstraint.getConstraintType(grConstraintEl.attributeValue("type")), grConstraintEl.attributeValue("pref"));
}
}
getModel().addConstraint(c);
for (Iterator<?> i2 = grConstraintEl.elementIterator("class"); i2.hasNext(); ) {
String classId = ((Element) i2.next()).attributeValue("id");
Lecture other = lectures.get(classId);
if (other != null)
c.addVariable(other);
else
iProgress.warn("Class " + classId + " does not exists, but it is referred from group constraint " + c.getId() + " (" + c.getName() + ")");
}
grConstraintElements.put(grConstraintEl.attributeValue("id"), grConstraintEl);
groupConstraints.put(grConstraintEl.attributeValue("id"), c);
iProgress.incProgress();
}
iProgress.setPhase("Loading students ...", root.element("students").elements("student").size());
boolean initialSectioning = true;
HashMap<Long, Student> students = new HashMap<Long, Student>();
HashMap<Long, Set<Student>> offering2students = new HashMap<Long, Set<Student>>();
for (Iterator<?> i1 = root.element("students").elementIterator("student"); i1.hasNext(); ) {
Element studentEl = (Element) i1.next();
List<Lecture> lecturesThisStudent = new ArrayList<Lecture>();
Long studentId = Long.valueOf(studentEl.attributeValue("id"));
Student student = students.get(studentId);
if (student == null) {
student = new Student(studentId);
students.put(studentId, student);
getModel().addStudent(student);
}
student.setAcademicArea(studentEl.attributeValue("area"));
student.setAcademicClassification(studentEl.attributeValue("classification"));
student.setMajor(studentEl.attributeValue("major"));
student.setCurriculum(studentEl.attributeValue("curriculum"));
for (Iterator<?> i2 = studentEl.elementIterator("offering"); i2.hasNext(); ) {
Element ofEl = (Element) i2.next();
Long offeringId = Long.valueOf(ofEl.attributeValue("id"));
String priority = ofEl.attributeValue("priority");
student.addOffering(offeringId, Double.parseDouble(ofEl.attributeValue("weight", "1.0")), priority == null ? null : Double.valueOf(priority));
Set<Student> studentsThisOffering = offering2students.get(offeringId);
if (studentsThisOffering == null) {
studentsThisOffering = new HashSet<Student>();
offering2students.put(offeringId, studentsThisOffering);
}
studentsThisOffering.add(student);
String altId = ofEl.attributeValue("alternative");
if (altId != null)
student.addAlternatives(Long.valueOf(altId), offeringId);
}
for (Iterator<?> i2 = studentEl.elementIterator("class"); i2.hasNext(); ) {
String classId = ((Element) i2.next()).attributeValue("id");
Lecture lecture = lectures.get(classId);
if (lecture == null) {
iProgress.warn("Class " + classId + " does not exists, but it is referred from student " + student.getId());
continue;
}
if (lecture.isCommitted()) {
if (sectionWholeCourse && (lecture.getParent() != null || lecture.getConfiguration() != null)) {
// committed, but with course structure -- sectioning can be used
student.addLecture(lecture);
student.addConfiguration(lecture.getConfiguration());
lecture.addStudent(getAssignment(), student);
lecturesThisStudent.add(lecture);
initialSectioning = false;
} else {
Placement placement = assignedPlacements.get(lecture);
student.addCommitedPlacement(placement);
}
} else {
student.addLecture(lecture);
student.addConfiguration(lecture.getConfiguration());
lecture.addStudent(getAssignment(), student);
lecturesThisStudent.add(lecture);
initialSectioning = false;
}
}
for (Iterator<?> i2 = studentEl.elementIterator("prohibited-class"); i2.hasNext(); ) {
String classId = ((Element) i2.next()).attributeValue("id");
Lecture lecture = lectures.get(classId);
if (lecture != null)
student.addCanNotEnroll(lecture);
else
iProgress.warn("Class " + classId + " does not exists, but it is referred from student " + student.getId());
}
if (studentEl.attributeValue("instructor") != null)
student.setInstructor(instructorConstraints.get(studentEl.attributeValue("instructor")));
iProgress.incProgress();
}
if (root.element("groups") != null) {
iProgress.setPhase("Loading student groups ...", root.element("groups").elements("group").size());
for (Iterator<?> i1 = root.element("groups").elementIterator("group"); i1.hasNext(); ) {
Element groupEl = (Element) i1.next();
long groupId = Long.parseLong(groupEl.attributeValue("id"));
StudentGroup group = new StudentGroup(groupId, Double.parseDouble(groupEl.attributeValue("weight", "1.0")), groupEl.attributeValue("name", "Group-" + groupId));
getModel().addStudentGroup(group);
for (Iterator<?> i2 = groupEl.elementIterator("student"); i2.hasNext(); ) {
Element studentEl = (Element) i2.next();
Student student = students.get(Long.valueOf(studentEl.attributeValue("id")));
if (student != null) {
group.addStudent(student);
student.addGroup(group);
}
}
}
}
for (List<Lecture> sames : sameLectures.values()) {
for (Lecture lect : sames) {
lect.setSameSubpartLectures(sames);
}
}
if (initialSectioning) {
iProgress.setPhase("Initial sectioning ...", offering2students.size());
for (Map.Entry<Long, Set<Student>> entry : offering2students.entrySet()) {
Long offeringId = entry.getKey();
Set<Student> studentsThisOffering = entry.getValue();
List<Configuration> altConfigs = alternativeConfigurations.get(offeringId);
getModel().getStudentSectioning().initialSectioning(getAssignment(), offeringId, String.valueOf(offeringId), studentsThisOffering, altConfigs);
iProgress.incProgress();
}
for (Student student : students.values()) {
student.clearDistanceCache();
if (student.getInstructor() != null)
for (Lecture lecture : student.getInstructor().variables()) {
student.addLecture(lecture);
student.addConfiguration(lecture.getConfiguration());
lecture.addStudent(getAssignment(), student);
}
}
}
iProgress.setPhase("Computing jenrl ...", students.size());
HashMap<Lecture, HashMap<Lecture, JenrlConstraint>> jenrls = new HashMap<Lecture, HashMap<Lecture, JenrlConstraint>>();
for (Iterator<Student> i1 = students.values().iterator(); i1.hasNext(); ) {
Student st = i1.next();
for (Iterator<Lecture> i2 = st.getLectures().iterator(); i2.hasNext(); ) {
Lecture l1 = i2.next();
for (Iterator<Lecture> i3 = st.getLectures().iterator(); i3.hasNext(); ) {
Lecture l2 = i3.next();
if (l1.getId() >= l2.getId())
continue;
HashMap<Lecture, JenrlConstraint> x = jenrls.get(l1);
if (x == null) {
x = new HashMap<Lecture, JenrlConstraint>();
jenrls.put(l1, x);
}
JenrlConstraint jenrl = x.get(l2);
if (jenrl == null) {
jenrl = new JenrlConstraint();
jenrl.addVariable(l1);
jenrl.addVariable(l2);
getModel().addConstraint(jenrl);
x.put(l2, jenrl);
}
jenrl.incJenrl(getAssignment(), st);
}
}
iProgress.incProgress();
}
if (iDeptBalancing) {
iProgress.setPhase("Creating dept. spread constraints ...", getModel().variables().size());
HashMap<Long, DepartmentSpreadConstraint> depSpreadConstraints = new HashMap<Long, DepartmentSpreadConstraint>();
for (Lecture lecture : getModel().variables()) {
if (lecture.getDepartment() == null)
continue;
DepartmentSpreadConstraint deptConstr = depSpreadConstraints.get(lecture.getDepartment());
if (deptConstr == null) {
String name = depts.get(lecture.getDepartment());
deptConstr = new DepartmentSpreadConstraint(getModel().getProperties(), lecture.getDepartment(), (name != null ? name : "d" + lecture.getDepartment()));
depSpreadConstraints.put(lecture.getDepartment(), deptConstr);
getModel().addConstraint(deptConstr);
}
deptConstr.addVariable(lecture);
iProgress.incProgress();
}
}
if (getModel().getProperties().getPropertyBoolean("General.PurgeInvalidPlacements", true)) {
iProgress.setPhase("Purging invalid placements ...", getModel().variables().size());
for (Lecture lecture : getModel().variables()) {
lecture.purgeInvalidValues(iInteractiveMode);
iProgress.incProgress();
}
}
if (getModel().hasConstantVariables() && getModel().constantVariables().size() > 0) {
iProgress.setPhase("Assigning committed classes ...", assignedPlacements.size());
for (Map.Entry<Lecture, Placement> entry : assignedPlacements.entrySet()) {
Lecture lecture = entry.getKey();
Placement placement = entry.getValue();
if (!lecture.isCommitted()) {
iProgress.incProgress();
continue;
}
lecture.setConstantValue(placement);
getModel().weaken(getAssignment(), placement);
Map<Constraint<Lecture, Placement>, Set<Placement>> conflictConstraints = getModel().conflictConstraints(getAssignment(), placement);
if (conflictConstraints.isEmpty()) {
getAssignment().assign(0, placement);
} else {
iProgress.warn("WARNING: Unable to assign " + lecture.getName() + " := " + placement.getName());
iProgress.debug(" Reason:");
for (Constraint<Lecture, Placement> c : conflictConstraints.keySet()) {
Set<Placement> vals = conflictConstraints.get(c);
for (Placement v : vals) {
iProgress.debug(" " + v.variable().getName() + " = " + v.getName());
}
iProgress.debug(" in constraint " + c);
}
}
iProgress.incProgress();
}
}
if (currentSolution != null) {
iProgress.setPhase("Creating best assignment ...", 2 * getModel().variables().size());
for (Lecture lecture : getModel().variables()) {
iProgress.incProgress();
Placement placement = lecture.getBestAssignment();
if (placement == null)
continue;
getModel().weaken(getAssignment(), placement);
getAssignment().assign(0, placement);
}
currentSolution.saveBest();
for (Lecture lecture : getModel().variables()) {
iProgress.incProgress();
getAssignment().unassign(0, lecture);
}
}
iProgress.setPhase("Creating initial assignment ...", assignedPlacements.size());
for (Map.Entry<Lecture, Placement> entry : assignedPlacements.entrySet()) {
Lecture lecture = entry.getKey();
Placement placement = entry.getValue();
if (lecture.isCommitted()) {
iProgress.incProgress();
continue;
}
getModel().weaken(getAssignment(), placement);
Map<Constraint<Lecture, Placement>, Set<Placement>> conflictConstraints = getModel().conflictConstraints(getAssignment(), placement);
if (conflictConstraints.isEmpty()) {
if (!placement.isValid()) {
iProgress.warn("WARNING: Lecture " + lecture.getName() + " does not contain assignment " + placement.getLongName(true) + " in its domain (" + placement.getNotValidReason(getAssignment(), true) + ").");
} else
getAssignment().assign(0, placement);
} else {
iProgress.warn("WARNING: Unable to assign " + lecture.getName() + " := " + placement.getName());
iProgress.debug(" Reason:");
for (Constraint<Lecture, Placement> c : conflictConstraints.keySet()) {
Set<Placement> vals = conflictConstraints.get(c);
for (Placement v : vals) {
iProgress.debug(" " + v.variable().getName() + " = " + v.getName());
}
iProgress.debug(" in constraint " + c);
}
}
iProgress.incProgress();
}
if (initialSectioning && getAssignment().nrAssignedVariables() != 0 && !getModel().getProperties().getPropertyBoolean("Global.LoadStudentEnrlsFromSolution", false))
getModel().switchStudents(getAssignment());
if (iForcedPerturbances > 0) {
iProgress.setPhase("Forcing perturbances", iForcedPerturbances);
for (int i = 0; i < iForcedPerturbances; i++) {
iProgress.setProgress(i);
Lecture var = null;
do {
var = ToolBox.random(getModel().variables());
} while (var.getInitialAssignment() == null || var.values(getAssignment()).size() <= 1);
var.removeInitialValue();
}
}
/*
for (Constraint<Lecture, Placement> c : getModel().constraints()) {
if (c instanceof SpreadConstraint)
((SpreadConstraint) c).init();
if (c instanceof DiscouragedRoomConstraint)
((DiscouragedRoomConstraint) c).setEnabled(true);
if (c instanceof MinimizeNumberOfUsedRoomsConstraint)
((MinimizeNumberOfUsedRoomsConstraint) c).setEnabled(true);
if (c instanceof MinimizeNumberOfUsedGroupsOfTime)
((MinimizeNumberOfUsedGroupsOfTime) c).setEnabled(true);
}
*/
}
Also used :
DiscouragedRoomConstraint(org.cpsolver.coursett.constraint.DiscouragedRoomConstraint)
RoomConstraint(org.cpsolver.coursett.constraint.RoomConstraint)
Lecture(org.cpsolver.coursett.model.Lecture)
Configuration(org.cpsolver.coursett.model.Configuration)
HashMap(java.util.HashMap)
DepartmentSpreadConstraint(org.cpsolver.coursett.constraint.DepartmentSpreadConstraint)
DiscouragedRoomConstraint(org.cpsolver.coursett.constraint.DiscouragedRoomConstraint)
ClassLimitConstraint(org.cpsolver.coursett.constraint.ClassLimitConstraint)
IgnoreStudentConflictsConstraint(org.cpsolver.coursett.constraint.IgnoreStudentConflictsConstraint)
InstructorConstraint(org.cpsolver.coursett.constraint.InstructorConstraint)
SoftInstructorConstraint(org.cpsolver.coursett.constraint.SoftInstructorConstraint)
MinimizeNumberOfUsedRoomsConstraint(org.cpsolver.coursett.constraint.MinimizeNumberOfUsedRoomsConstraint)
SpreadConstraint(org.cpsolver.coursett.constraint.SpreadConstraint)
GroupConstraint(org.cpsolver.coursett.constraint.GroupConstraint)
Constraint(org.cpsolver.ifs.model.Constraint)
RoomConstraint(org.cpsolver.coursett.constraint.RoomConstraint)
JenrlConstraint(org.cpsolver.coursett.constraint.JenrlConstraint)
DepartmentSpreadConstraint(org.cpsolver.coursett.constraint.DepartmentSpreadConstraint)
ArrayList(java.util.ArrayList)
DepartmentSpreadConstraint(org.cpsolver.coursett.constraint.DepartmentSpreadConstraint)
SpreadConstraint(org.cpsolver.coursett.constraint.SpreadConstraint)
Placement(org.cpsolver.coursett.model.Placement)
ArrayList(java.util.ArrayList)
List(java.util.List)
IgnoreStudentConflictsConstraint(org.cpsolver.coursett.constraint.IgnoreStudentConflictsConstraint)
Student(org.cpsolver.coursett.model.Student)
ClassLimitConstraint(org.cpsolver.coursett.constraint.ClassLimitConstraint)
GroupConstraint(org.cpsolver.coursett.constraint.GroupConstraint)
HashMap(java.util.HashMap)
Map(java.util.Map)
MinimizeNumberOfUsedGroupsOfTime(org.cpsolver.coursett.constraint.MinimizeNumberOfUsedGroupsOfTime)
HashSet(java.util.HashSet)
Set(java.util.Set)
BitSet(java.util.BitSet)
TimeLocation(org.cpsolver.coursett.model.TimeLocation)
Element(org.dom4j.Element)
DiscouragedRoomConstraint(org.cpsolver.coursett.constraint.DiscouragedRoomConstraint)
RoomSharingModel(org.cpsolver.coursett.model.RoomSharingModel)
MinimizeNumberOfUsedRoomsConstraint(org.cpsolver.coursett.constraint.MinimizeNumberOfUsedRoomsConstraint)
JenrlConstraint(org.cpsolver.coursett.constraint.JenrlConstraint)
RoomLocation(org.cpsolver.coursett.model.RoomLocation)
Hashtable(java.util.Hashtable)
SoftInstructorConstraint(org.cpsolver.coursett.constraint.SoftInstructorConstraint)
DepartmentSpreadConstraint(org.cpsolver.coursett.constraint.DepartmentSpreadConstraint)
DiscouragedRoomConstraint(org.cpsolver.coursett.constraint.DiscouragedRoomConstraint)
ClassLimitConstraint(org.cpsolver.coursett.constraint.ClassLimitConstraint)
IgnoreStudentConflictsConstraint(org.cpsolver.coursett.constraint.IgnoreStudentConflictsConstraint)
InstructorConstraint(org.cpsolver.coursett.constraint.InstructorConstraint)
SoftInstructorConstraint(org.cpsolver.coursett.constraint.SoftInstructorConstraint)
MinimizeNumberOfUsedRoomsConstraint(org.cpsolver.coursett.constraint.MinimizeNumberOfUsedRoomsConstraint)
SpreadConstraint(org.cpsolver.coursett.constraint.SpreadConstraint)
GroupConstraint(org.cpsolver.coursett.constraint.GroupConstraint)
Constraint(org.cpsolver.ifs.model.Constraint)
RoomConstraint(org.cpsolver.coursett.constraint.RoomConstraint)
JenrlConstraint(org.cpsolver.coursett.constraint.JenrlConstraint)
InstructorConstraint(org.cpsolver.coursett.constraint.InstructorConstraint)
SoftInstructorConstraint(org.cpsolver.coursett.constraint.SoftInstructorConstraint)
FlexibleConstraintType(org.cpsolver.coursett.constraint.FlexibleConstraint.FlexibleConstraintType)
StudentGroup(org.cpsolver.coursett.model.StudentGroup)
Example 3 with Constraint
use of org.cpsolver.ifs.model.Constraint in project cpsolver by UniTime.
the class TimetableXMLSaver method doSave.
protected void doSave(Element root) {
root.addAttribute("version", "2.5");
root.addAttribute("initiative", getModel().getProperties().getProperty("Data.Initiative"));
root.addAttribute("term", getModel().getProperties().getProperty("Data.Term"));
root.addAttribute("year", String.valueOf(getModel().getYear()));
root.addAttribute("created", String.valueOf(new Date()));
root.addAttribute("nrDays", String.valueOf(Constants.DAY_CODES.length));
root.addAttribute("slotsPerDay", String.valueOf(Constants.SLOTS_PER_DAY));
if (!iConvertIds && getModel().getProperties().getProperty("General.SessionId") != null)
root.addAttribute("session", getModel().getProperties().getProperty("General.SessionId"));
if (iShowNames && !iConvertIds && getModel().getProperties().getProperty("General.SolverGroupId") != null)
root.addAttribute("solverGroup", getId("solverGroup", getModel().getProperties().getProperty("General.SolverGroupId")));
HashMap<String, Element> roomElements = new HashMap<String, Element>();
Element roomsEl = root.addElement("rooms");
for (RoomConstraint roomConstraint : getModel().getRoomConstraints()) {
Element roomEl = roomsEl.addElement("room").addAttribute("id", getId("room", roomConstraint.getResourceId()));
roomEl.addAttribute("constraint", "true");
if (roomConstraint instanceof DiscouragedRoomConstraint)
roomEl.addAttribute("discouraged", "true");
if (iShowNames) {
roomEl.addAttribute("name", roomConstraint.getRoomName());
}
if (!iConvertIds && roomConstraint.getBuildingId() != null)
roomEl.addAttribute("building", getId("bldg", roomConstraint.getBuildingId()));
roomElements.put(getId("room", roomConstraint.getResourceId()), roomEl);
roomEl.addAttribute("capacity", String.valueOf(roomConstraint.getCapacity()));
if (roomConstraint.getPosX() != null && roomConstraint.getPosY() != null)
roomEl.addAttribute("location", roomConstraint.getPosX() + "," + roomConstraint.getPosY());
if (roomConstraint.getIgnoreTooFar())
roomEl.addAttribute("ignoreTooFar", "true");
if (!roomConstraint.getConstraint())
roomEl.addAttribute("fake", "true");
if (roomConstraint.getSharingModel() != null) {
RoomSharingModel sharingModel = roomConstraint.getSharingModel();
Element sharingEl = roomEl.addElement("sharing");
sharingEl.addElement("pattern").addAttribute("unit", String.valueOf(sharingModel.getStep())).setText(sharingModel.getPreferences());
sharingEl.addElement("freeForAll").addAttribute("value", String.valueOf(sharingModel.getFreeForAllPrefChar()));
sharingEl.addElement("notAvailable").addAttribute("value", String.valueOf(sharingModel.getNotAvailablePrefChar()));
for (Long id : sharingModel.getDepartmentIds()) {
sharingEl.addElement("department").addAttribute("value", String.valueOf(sharingModel.getCharacter(id))).addAttribute("id", getId("dept", id));
}
}
if (roomConstraint.getType() != null && iShowNames)
roomEl.addAttribute("type", roomConstraint.getType().toString());
Map<Long, Integer> travelTimes = getModel().getDistanceMetric().getTravelTimes().get(roomConstraint.getResourceId());
if (travelTimes != null)
for (Map.Entry<Long, Integer> time : travelTimes.entrySet()) roomEl.addElement("travel-time").addAttribute("id", getId("room", time.getKey())).addAttribute("minutes", time.getValue().toString());
}
Element instructorsEl = root.addElement("instructors");
Element departmentsEl = root.addElement("departments");
HashMap<Long, String> depts = new HashMap<Long, String>();
Element configsEl = (iShowNames ? root.addElement("configurations") : null);
HashSet<Configuration> configs = new HashSet<Configuration>();
Element classesEl = root.addElement("classes");
HashMap<Long, Element> classElements = new HashMap<Long, Element>();
List<Lecture> vars = new ArrayList<Lecture>(getModel().variables());
if (getModel().hasConstantVariables())
vars.addAll(getModel().constantVariables());
for (Lecture lecture : vars) {
Placement placement = getAssignment().getValue(lecture);
if (lecture.isCommitted() && placement == null)
placement = lecture.getInitialAssignment();
Placement initialPlacement = lecture.getInitialAssignment();
// if (initialPlacement==null) initialPlacement =
// (Placement)lecture.getAssignment();
Placement bestPlacement = lecture.getBestAssignment();
Element classEl = classesEl.addElement("class").addAttribute("id", getId("class", lecture.getClassId()));
classElements.put(lecture.getClassId(), classEl);
if (iShowNames && lecture.getNote() != null)
classEl.addAttribute("note", lecture.getNote());
if (iShowNames && !lecture.isCommitted())
classEl.addAttribute("ord", String.valueOf(lecture.getOrd()));
if (lecture.getWeight() != 1.0)
classEl.addAttribute("weight", String.valueOf(lecture.getWeight()));
if (iShowNames && lecture.getSolverGroupId() != null)
classEl.addAttribute("solverGroup", getId("solverGroup", lecture.getSolverGroupId()));
if (lecture.getParent() == null && lecture.getConfiguration() != null) {
if (!iShowNames)
classEl.addAttribute("offering", getId("offering", lecture.getConfiguration().getOfferingId().toString()));
classEl.addAttribute("config", getId("config", lecture.getConfiguration().getConfigId().toString()));
if (iShowNames && configs.add(lecture.getConfiguration())) {
configsEl.addElement("config").addAttribute("id", getId("config", lecture.getConfiguration().getConfigId().toString())).addAttribute("limit", String.valueOf(lecture.getConfiguration().getLimit())).addAttribute("offering", getId("offering", lecture.getConfiguration().getOfferingId().toString()));
}
}
classEl.addAttribute("committed", (lecture.isCommitted() ? "true" : "false"));
if (lecture.getParent() != null)
classEl.addAttribute("parent", getId("class", lecture.getParent().getClassId()));
if (lecture.getSchedulingSubpartId() != null)
classEl.addAttribute("subpart", getId("subpart", lecture.getSchedulingSubpartId()));
if (iShowNames && lecture.isCommitted() && placement != null && placement.getAssignmentId() != null) {
classEl.addAttribute("assignment", getId("assignment", placement.getAssignmentId()));
}
if (!lecture.isCommitted()) {
if (lecture.minClassLimit() == lecture.maxClassLimit()) {
classEl.addAttribute("classLimit", String.valueOf(lecture.maxClassLimit()));
} else {
classEl.addAttribute("minClassLimit", String.valueOf(lecture.minClassLimit()));
classEl.addAttribute("maxClassLimit", String.valueOf(lecture.maxClassLimit()));
}
if (lecture.roomToLimitRatio() != 1.0f)
classEl.addAttribute("roomToLimitRatio", sStudentWeightFormat.format(lecture.roomToLimitRatio()));
}
if (lecture.getNrRooms() != 1)
classEl.addAttribute("nrRooms", String.valueOf(lecture.getNrRooms()));
if (lecture.getNrRooms() > 1 && lecture.getMaxRoomCombinations() > 0)
classEl.addAttribute("maxRoomCombinations", String.valueOf(lecture.getMaxRoomCombinations()));
if (iShowNames)
classEl.addAttribute("name", lecture.getName());
if (lecture.getDeptSpreadConstraint() != null) {
classEl.addAttribute("department", getId("dept", lecture.getDeptSpreadConstraint().getDepartmentId()));
depts.put(lecture.getDeptSpreadConstraint().getDepartmentId(), lecture.getDeptSpreadConstraint().getName());
}
if (lecture.getScheduler() != null)
classEl.addAttribute("scheduler", getId("dept", lecture.getScheduler()));
for (InstructorConstraint ic : lecture.getInstructorConstraints()) {
Element instrEl = classEl.addElement("instructor").addAttribute("id", getId("inst", ic.getResourceId()));
if ((lecture.isCommitted() || iSaveCurrent) && placement != null)
instrEl.addAttribute("solution", "true");
if (iSaveInitial && initialPlacement != null)
instrEl.addAttribute("initial", "true");
if (iSaveBest && bestPlacement != null && !bestPlacement.equals(placement))
instrEl.addAttribute("best", "true");
}
for (RoomLocation rl : lecture.roomLocations()) {
Element roomLocationEl = classEl.addElement("room");
roomLocationEl.addAttribute("id", getId("room", rl.getId()));
roomLocationEl.addAttribute("pref", String.valueOf(rl.getPreference()));
if ((lecture.isCommitted() || iSaveCurrent) && placement != null && placement.hasRoomLocation(rl.getId()))
roomLocationEl.addAttribute("solution", "true");
if (iSaveInitial && initialPlacement != null && initialPlacement.hasRoomLocation(rl.getId()))
roomLocationEl.addAttribute("initial", "true");
if (iSaveBest && bestPlacement != null && !bestPlacement.equals(placement) && bestPlacement.hasRoomLocation(rl.getId()))
roomLocationEl.addAttribute("best", "true");
if (!roomElements.containsKey(getId("room", rl.getId()))) {
// room location without room constraint
Element roomEl = roomsEl.addElement("room").addAttribute("id", getId("room", rl.getId()));
roomEl.addAttribute("constraint", "false");
if (!iConvertIds && rl.getBuildingId() != null)
roomEl.addAttribute("building", getId("bldg", rl.getBuildingId()));
if (iShowNames) {
roomEl.addAttribute("name", rl.getName());
}
roomElements.put(getId("room", rl.getId()), roomEl);
roomEl.addAttribute("capacity", String.valueOf(rl.getRoomSize()));
if (rl.getPosX() != null && rl.getPosY() != null)
roomEl.addAttribute("location", rl.getPosX() + "," + rl.getPosY());
if (rl.getIgnoreTooFar())
roomEl.addAttribute("ignoreTooFar", "true");
}
}
boolean first = true;
Set<Long> dp = new HashSet<Long>();
for (TimeLocation tl : lecture.timeLocations()) {
Element timeLocationEl = classEl.addElement("time");
timeLocationEl.addAttribute("days", sDF[7].format(Long.parseLong(Integer.toBinaryString(tl.getDayCode()))));
timeLocationEl.addAttribute("start", String.valueOf(tl.getStartSlot()));
timeLocationEl.addAttribute("length", String.valueOf(tl.getLength()));
timeLocationEl.addAttribute("breakTime", String.valueOf(tl.getBreakTime()));
if (iShowNames) {
timeLocationEl.addAttribute("pref", String.valueOf(tl.getPreference()));
timeLocationEl.addAttribute("npref", String.valueOf(tl.getNormalizedPreference()));
} else {
timeLocationEl.addAttribute("pref", String.valueOf(tl.getNormalizedPreference()));
}
if (!iConvertIds && tl.getTimePatternId() != null)
timeLocationEl.addAttribute("pattern", getId("pat", tl.getTimePatternId()));
if (tl.getDatePatternId() != null && dp.add(tl.getDatePatternId())) {
Element dateEl = classEl.addElement("date");
dateEl.addAttribute("id", getId("dpat", String.valueOf(tl.getDatePatternId())));
if (iShowNames)
dateEl.addAttribute("name", tl.getDatePatternName());
dateEl.addAttribute("pattern", bitset2string(tl.getWeekCode()));
}
if (tl.getDatePatternPreference() != 0)
timeLocationEl.addAttribute("datePref", String.valueOf(tl.getDatePatternPreference()));
if (tl.getTimePatternId() == null && first) {
if (iShowNames)
classEl.addAttribute("datePatternName", tl.getDatePatternName());
classEl.addAttribute("dates", bitset2string(tl.getWeekCode()));
first = false;
}
if (tl.getDatePatternId() != null) {
timeLocationEl.addAttribute("date", getId("dpat", String.valueOf(tl.getDatePatternId())));
}
if ((lecture.isCommitted() || iSaveCurrent) && placement != null && placement.getTimeLocation().equals(tl))
timeLocationEl.addAttribute("solution", "true");
if (iSaveInitial && initialPlacement != null && initialPlacement.getTimeLocation().equals(tl))
timeLocationEl.addAttribute("initial", "true");
if (iSaveBest && bestPlacement != null && !bestPlacement.equals(placement) && bestPlacement.getTimeLocation().equals(tl))
timeLocationEl.addAttribute("best", "true");
}
}
for (InstructorConstraint ic : getModel().getInstructorConstraints()) {
if (iShowNames || ic.isIgnoreDistances() || ic instanceof SoftInstructorConstraint) {
Element instrEl = instructorsEl.addElement("instructor").addAttribute("id", getId("inst", ic.getResourceId()));
if (iShowNames) {
if (ic.getPuid() != null && ic.getPuid().length() > 0)
instrEl.addAttribute("puid", ic.getPuid());
instrEl.addAttribute("name", ic.getName());
if (ic.getType() != null && iShowNames)
instrEl.addAttribute("type", ic.getType().toString());
}
if (ic.isIgnoreDistances()) {
instrEl.addAttribute("ignDist", "true");
}
if (ic instanceof SoftInstructorConstraint)
instrEl.addAttribute("soft", "true");
}
if (ic.getUnavailabilities() != null) {
for (Placement placement : ic.getUnavailabilities()) {
Lecture lecture = placement.variable();
Element classEl = classElements.get(lecture.getClassId());
classEl.addElement("instructor").addAttribute("id", getId("inst", ic.getResourceId())).addAttribute("solution", "true");
}
}
}
if (instructorsEl.elements().isEmpty())
root.remove(instructorsEl);
Element grConstraintsEl = root.addElement("groupConstraints");
for (GroupConstraint gc : getModel().getGroupConstraints()) {
Element grEl = grConstraintsEl.addElement("constraint").addAttribute("id", getId("gr", String.valueOf(gc.getId())));
grEl.addAttribute("type", gc.getType().reference());
grEl.addAttribute("pref", gc.getPrologPreference());
for (Lecture l : gc.variables()) {
grEl.addElement("class").addAttribute("id", getId("class", l.getClassId()));
}
}
for (SpreadConstraint spread : getModel().getSpreadConstraints()) {
Element grEl = grConstraintsEl.addElement("constraint").addAttribute("id", getId("gr", String.valueOf(spread.getId())));
grEl.addAttribute("type", "SPREAD");
grEl.addAttribute("pref", Constants.sPreferenceRequired);
if (iShowNames)
grEl.addAttribute("name", spread.getName());
for (Lecture l : spread.variables()) {
grEl.addElement("class").addAttribute("id", getId("class", l.getClassId()));
}
}
for (Constraint<Lecture, Placement> c : getModel().constraints()) {
if (c instanceof MinimizeNumberOfUsedRoomsConstraint) {
Element grEl = grConstraintsEl.addElement("constraint").addAttribute("id", getId("gr", String.valueOf(c.getId())));
grEl.addAttribute("type", "MIN_ROOM_USE");
grEl.addAttribute("pref", Constants.sPreferenceRequired);
for (Lecture l : c.variables()) {
grEl.addElement("class").addAttribute("id", getId("class", l.getClassId()));
}
}
if (c instanceof MinimizeNumberOfUsedGroupsOfTime) {
Element grEl = grConstraintsEl.addElement("constraint").addAttribute("id", getId("gr", String.valueOf(c.getId())));
grEl.addAttribute("type", ((MinimizeNumberOfUsedGroupsOfTime) c).getConstraintName());
grEl.addAttribute("pref", Constants.sPreferenceRequired);
for (Lecture l : c.variables()) {
grEl.addElement("class").addAttribute("id", getId("class", l.getClassId()));
}
}
if (c instanceof IgnoreStudentConflictsConstraint) {
Element grEl = grConstraintsEl.addElement("constraint").addAttribute("id", getId("gr", String.valueOf(c.getId())));
grEl.addAttribute("type", IgnoreStudentConflictsConstraint.REFERENCE);
grEl.addAttribute("pref", Constants.sPreferenceRequired);
for (Lecture l : c.variables()) {
grEl.addElement("class").addAttribute("id", getId("class", l.getClassId()));
}
}
}
for (ClassLimitConstraint clc : getModel().getClassLimitConstraints()) {
Element grEl = grConstraintsEl.addElement("constraint").addAttribute("id", getId("gr", String.valueOf(clc.getId())));
grEl.addAttribute("type", "CLASS_LIMIT");
grEl.addAttribute("pref", Constants.sPreferenceRequired);
if (clc.getParentLecture() != null) {
grEl.addElement("parentClass").addAttribute("id", getId("class", clc.getParentLecture().getClassId()));
} else
grEl.addAttribute("courseLimit", String.valueOf(clc.classLimit() - clc.getClassLimitDelta()));
if (clc.getClassLimitDelta() != 0)
grEl.addAttribute("delta", String.valueOf(clc.getClassLimitDelta()));
if (iShowNames)
grEl.addAttribute("name", clc.getName());
for (Lecture l : clc.variables()) {
grEl.addElement("class").addAttribute("id", getId("class", l.getClassId()));
}
}
for (FlexibleConstraint gc : getModel().getFlexibleConstraints()) {
Element flEl = grConstraintsEl.addElement("constraint").addAttribute("id", getId("gr", String.valueOf(gc.getId())));
flEl.addAttribute("reference", gc.getReference());
flEl.addAttribute("owner", gc.getOwner());
flEl.addAttribute("pref", gc.getPrologPreference());
flEl.addAttribute("type", gc.getType().toString());
for (Lecture l : gc.variables()) {
flEl.addElement("class").addAttribute("id", getId("class", l.getClassId()));
}
}
HashMap<Student, List<String>> students = new HashMap<Student, List<String>>();
for (Lecture lecture : vars) {
for (Student student : lecture.students()) {
List<String> enrls = students.get(student);
if (enrls == null) {
enrls = new ArrayList<String>();
students.put(student, enrls);
}
enrls.add(getId("class", lecture.getClassId()));
}
}
Element studentsEl = root.addElement("students");
Element groupsEl = root.addElement("groups");
Map<StudentGroup, Element> groups = new HashMap<StudentGroup, Element>();
for (Student student : new TreeSet<Student>(students.keySet())) {
Element stEl = studentsEl.addElement("student").addAttribute("id", getId("student", student.getId()));
if (iShowNames) {
if (student.getAcademicArea() != null)
stEl.addAttribute("area", student.getAcademicArea());
if (student.getAcademicClassification() != null)
stEl.addAttribute("classification", student.getAcademicClassification());
if (student.getMajor() != null)
stEl.addAttribute("major", student.getMajor());
if (student.getCurriculum() != null)
stEl.addAttribute("curriculum", student.getCurriculum());
}
for (Map.Entry<Long, Double> entry : student.getOfferingsMap().entrySet()) {
Long offeringId = entry.getKey();
Double weight = entry.getValue();
Element offEl = stEl.addElement("offering").addAttribute("id", getId("offering", offeringId.toString()));
if (weight.doubleValue() != 1.0)
offEl.addAttribute("weight", sStudentWeightFormat.format(weight));
Double priority = student.getPriority(offeringId);
if (priority != null)
offEl.addAttribute("priority", priority.toString());
Long altId = student.getAlternative(offeringId);
if (altId != null)
offEl.addAttribute("alternative", altId.toString());
}
if (iExportStudentSectioning || getModel().nrUnassignedVariables(getAssignment()) == 0 || student.getOfferingsMap().isEmpty()) {
List<String> lectures = students.get(student);
Collections.sort(lectures);
for (String classId : lectures) {
stEl.addElement("class").addAttribute("id", classId);
}
}
Map<Long, Set<Lecture>> canNotEnroll = student.canNotEnrollSections();
if (canNotEnroll != null) {
for (Set<Lecture> canNotEnrollLects : canNotEnroll.values()) {
for (Iterator<Lecture> i3 = canNotEnrollLects.iterator(); i3.hasNext(); ) {
stEl.addElement("prohibited-class").addAttribute("id", getId("class", (i3.next()).getClassId()));
}
}
}
if (student.getCommitedPlacements() != null) {
for (Placement placement : student.getCommitedPlacements()) {
stEl.addElement("class").addAttribute("id", getId("class", placement.variable().getClassId()));
}
}
if (student.getInstructor() != null)
stEl.addAttribute("instructor", getId("inst", student.getInstructor().getResourceId()));
for (StudentGroup group : student.getGroups()) {
Element groupEl = groups.get(group);
if (groupEl == null) {
groupEl = groupsEl.addElement("group");
groupEl.addAttribute("id", getId("group", group.getId()));
if (group.getWeight() != 1.0)
groupEl.addAttribute("weight", String.valueOf(group.getWeight()));
if (iShowNames && group.getName() != null)
groupEl.addAttribute("name", group.getName());
groups.put(group, groupEl);
}
groupEl.addElement("student").addAttribute("id", getId("student", student.getId()));
}
}
if (getModel().getProperties().getPropertyInt("MPP.GenTimePert", 0) > 0) {
Element perturbationsEl = root.addElement("perturbations");
int nrChanges = getModel().getProperties().getPropertyInt("MPP.GenTimePert", 0);
List<Lecture> lectures = new ArrayList<Lecture>();
while (lectures.size() < nrChanges) {
Lecture lecture = ToolBox.random(getAssignment().assignedVariables());
if (lecture.isCommitted() || lecture.timeLocations().size() <= 1 || lectures.contains(lecture))
continue;
Placement placement = getAssignment().getValue(lecture);
TimeLocation tl = placement.getTimeLocation();
perturbationsEl.addElement("class").addAttribute("id", getId("class", lecture.getClassId())).addAttribute("days", sDF[7].format(Long.parseLong(Integer.toBinaryString(tl.getDayCode())))).addAttribute("start", String.valueOf(tl.getStartSlot())).addAttribute("length", String.valueOf(tl.getLength()));
lectures.add(lecture);
}
}
for (Map.Entry<Long, String> entry : depts.entrySet()) {
Long id = entry.getKey();
String name = entry.getValue();
if (iShowNames) {
departmentsEl.addElement("department").addAttribute("id", getId("dept", id.toString())).addAttribute("name", name);
}
}
if (departmentsEl.elements().isEmpty())
root.remove(departmentsEl);
}
Also used :
DiscouragedRoomConstraint(org.cpsolver.coursett.constraint.DiscouragedRoomConstraint)
RoomConstraint(org.cpsolver.coursett.constraint.RoomConstraint)
Lecture(org.cpsolver.coursett.model.Lecture)
Configuration(org.cpsolver.coursett.model.Configuration)
HashMap(java.util.HashMap)
ArrayList(java.util.ArrayList)
SpreadConstraint(org.cpsolver.coursett.constraint.SpreadConstraint)
FlexibleConstraint(org.cpsolver.coursett.constraint.FlexibleConstraint)
Placement(org.cpsolver.coursett.model.Placement)
TreeSet(java.util.TreeSet)
ArrayList(java.util.ArrayList)
List(java.util.List)
IgnoreStudentConflictsConstraint(org.cpsolver.coursett.constraint.IgnoreStudentConflictsConstraint)
HashSet(java.util.HashSet)
Student(org.cpsolver.coursett.model.Student)
ClassLimitConstraint(org.cpsolver.coursett.constraint.ClassLimitConstraint)
GroupConstraint(org.cpsolver.coursett.constraint.GroupConstraint)
HashMap(java.util.HashMap)
Map(java.util.Map)
MinimizeNumberOfUsedGroupsOfTime(org.cpsolver.coursett.constraint.MinimizeNumberOfUsedGroupsOfTime)
TreeSet(java.util.TreeSet)
HashSet(java.util.HashSet)
Set(java.util.Set)
BitSet(java.util.BitSet)
TimeLocation(org.cpsolver.coursett.model.TimeLocation)
Element(org.dom4j.Element)
DiscouragedRoomConstraint(org.cpsolver.coursett.constraint.DiscouragedRoomConstraint)
RoomSharingModel(org.cpsolver.coursett.model.RoomSharingModel)
MinimizeNumberOfUsedRoomsConstraint(org.cpsolver.coursett.constraint.MinimizeNumberOfUsedRoomsConstraint)
RoomLocation(org.cpsolver.coursett.model.RoomLocation)
SoftInstructorConstraint(org.cpsolver.coursett.constraint.SoftInstructorConstraint)
Date(java.util.Date)
InstructorConstraint(org.cpsolver.coursett.constraint.InstructorConstraint)
SoftInstructorConstraint(org.cpsolver.coursett.constraint.SoftInstructorConstraint)
DiscouragedRoomConstraint(org.cpsolver.coursett.constraint.DiscouragedRoomConstraint)
ClassLimitConstraint(org.cpsolver.coursett.constraint.ClassLimitConstraint)
IgnoreStudentConflictsConstraint(org.cpsolver.coursett.constraint.IgnoreStudentConflictsConstraint)
InstructorConstraint(org.cpsolver.coursett.constraint.InstructorConstraint)
SoftInstructorConstraint(org.cpsolver.coursett.constraint.SoftInstructorConstraint)
MinimizeNumberOfUsedRoomsConstraint(org.cpsolver.coursett.constraint.MinimizeNumberOfUsedRoomsConstraint)
SpreadConstraint(org.cpsolver.coursett.constraint.SpreadConstraint)
GroupConstraint(org.cpsolver.coursett.constraint.GroupConstraint)
Constraint(org.cpsolver.ifs.model.Constraint)
FlexibleConstraint(org.cpsolver.coursett.constraint.FlexibleConstraint)
RoomConstraint(org.cpsolver.coursett.constraint.RoomConstraint)
StudentGroup(org.cpsolver.coursett.model.StudentGroup)
Example 4 with Constraint
use of org.cpsolver.ifs.model.Constraint in project cpsolver by UniTime.
the class GroupConstraint method getCurrentPreference.
/**
* Current constraint preference change (if given placement is assigned)
* @param assignment current assignment
* @param placement placement that is being considered
* @return change in the current preference, if assigned
*/
public int getCurrentPreference(Assignment<Lecture, Placement> assignment, Placement placement) {
// no preference
if (isHard())
return 0;
// not enough variable
if (countAssignedVariables(assignment) + (assignment.getValue(placement.variable()) == null ? 1 : 0) < 2)
return 0;
if (getType().is(Flag.MAX_HRS_DAY)) {
HashMap<Lecture, Placement> assignments = new HashMap<Lecture, Placement>();
assignments.put(placement.variable(), placement);
HashMap<Lecture, Placement> unassignments = new HashMap<Lecture, Placement>();
unassignments.put(placement.variable(), null);
int after = 0;
int before = 0;
for (int dayCode : Constants.DAY_CODES) {
if (iMaxNHoursADayConsiderDatePatterns) {
for (BitSet week : ((TimetableModel) getModel()).getWeeks()) {
after += Math.max(0, nrSlotsADay(assignment, dayCode, week, assignments, null) - getType().getMax());
before += Math.max(0, nrSlotsADay(assignment, dayCode, week, unassignments, null) - getType().getMax());
}
} else {
after += Math.max(0, nrSlotsADay(assignment, dayCode, null, assignments, null) - getType().getMax());
before += Math.max(0, nrSlotsADay(assignment, dayCode, null, unassignments, null) - getType().getMax());
}
}
return (after > 0 ? Math.abs(iPreference) * after / 12 : -Math.abs(iPreference)) - (before > 0 ? Math.abs(iPreference) * before / 12 : -Math.abs(iPreference));
}
int nrViolatedPairsAfter = 0;
int nrViolatedPairsBefore = 0;
for (Lecture v1 : variables()) {
for (Lecture v2 : variables()) {
if (v1.getId() >= v2.getId())
continue;
Placement p1 = (v1.equals(placement.variable()) ? null : assignment.getValue(v1));
Placement p2 = (v2.equals(placement.variable()) ? null : assignment.getValue(v2));
if (p1 != null && p2 != null && !isSatisfiedPair(assignment, p1, p2))
nrViolatedPairsBefore++;
if (v1.equals(placement.variable()))
p1 = placement;
if (v2.equals(placement.variable()))
p2 = placement;
if (p1 != null && p2 != null && !isSatisfiedPair(assignment, p1, p2))
nrViolatedPairsAfter++;
}
}
if (getType().is(Flag.BACK_TO_BACK)) {
HashMap<Lecture, Placement> assignments = new HashMap<Lecture, Placement>();
assignments.put(placement.variable(), placement);
Set<Placement> conflicts = new HashSet<Placement>();
if (isSatisfiedSeq(assignment, assignments, conflicts))
nrViolatedPairsAfter += conflicts.size();
else
nrViolatedPairsAfter = variables().size();
HashMap<Lecture, Placement> unassignments = new HashMap<Lecture, Placement>();
unassignments.put(placement.variable(), null);
Set<Placement> previous = new HashSet<Placement>();
if (isSatisfiedSeq(assignment, unassignments, previous))
nrViolatedPairsBefore += previous.size();
else
nrViolatedPairsBefore = variables().size();
}
return (nrViolatedPairsAfter > 0 ? Math.abs(iPreference) * nrViolatedPairsAfter : -Math.abs(iPreference)) - (nrViolatedPairsBefore > 0 ? Math.abs(iPreference) * nrViolatedPairsBefore : -Math.abs(iPreference));
}
Also used :
Lecture(org.cpsolver.coursett.model.Lecture)
Placement(org.cpsolver.coursett.model.Placement)
HashMap(java.util.HashMap)
BitSet(java.util.BitSet)
TimetableModel(org.cpsolver.coursett.model.TimetableModel)
WeakeningConstraint(org.cpsolver.ifs.model.WeakeningConstraint)
Constraint(org.cpsolver.ifs.model.Constraint)
GlobalConstraint(org.cpsolver.ifs.model.GlobalConstraint)
HashSet(java.util.HashSet)
Example 5 with Constraint
use of org.cpsolver.ifs.model.Constraint in project cpsolver by UniTime.
the class TimetableModel method generate.
@SuppressWarnings("unchecked")
public static TimetableModel generate(DataProperties cfg, Assignment<Activity, Location> assignment) {
int nrDays = cfg.getPropertyInt("Generator.NrDays", 5);
int nrHours = cfg.getPropertyInt("Generator.NrHours", 20);
int nrSlots = nrDays * nrHours;
TimetableModel m = new TimetableModel(nrDays, nrHours);
int nrRooms = cfg.getPropertyInt("Generator.NrRooms", 20);
int nrInstructors = cfg.getPropertyInt("Generator.NrInstructors", 20);
int nrClasses = cfg.getPropertyInt("Generator.NrClasses", 20);
int nrGroupsOfRooms = cfg.getPropertyInt("Generator.NrGroupsOfRooms", 20);
int nrRoomsInGroupMin = cfg.getPropertyInt("Generator.NrRoomsInGroupMin", 1);
int nrRoomsInGroupMax = cfg.getPropertyInt("Generator.NrRoomsInGroupMax", 10);
int nrRoomInGroupMin = cfg.getPropertyInt("Generator.NrRoomInGroupMin", 1);
double fillFactor = cfg.getPropertyDouble("Generator.FillFactor", 0.8);
int maxLength = cfg.getPropertyInt("Generator.ActivityLengthMax", 5);
double hardFreeResource = cfg.getPropertyDouble("Generator.HardFreeResource", 0.05);
double softFreeResource = cfg.getPropertyDouble("Generator.SoftFreeResource", 0.3);
double softUsedResource = cfg.getPropertyDouble("Generator.SoftUsedResource", 0.05);
double softUsedActivity = cfg.getPropertyDouble("Generator.SoftUsedActivity", 0.05);
double softFreeActivity = cfg.getPropertyDouble("Generator.SoftFreeActivity", 0.3);
double hardFreeActivity = cfg.getPropertyDouble("Generator.HardFreeActivity", 0.05);
int nrDependencies = cfg.getPropertyInt("Generator.NrDependencies", 50);
Resource[] rooms = new Resource[nrRooms];
ArrayList<ArrayList<Resource>>[] groupForRoom = new ArrayList[nrRooms];
for (int i = 0; i < nrRooms; i++) {
rooms[i] = new Resource("r" + (i + 1), Resource.TYPE_ROOM, "Room " + (i + 1));
groupForRoom[i] = new ArrayList<ArrayList<Resource>>();
m.addConstraint(rooms[i]);
}
ArrayList<Resource>[] groupOfRooms = new ArrayList[nrGroupsOfRooms];
for (int i = 0; i < nrGroupsOfRooms; i++) {
groupOfRooms[i] = new ArrayList<Resource>();
for (int j = 0; j < ToolBox.random(1 + nrRoomsInGroupMax - nrRoomsInGroupMin) + nrRoomsInGroupMin; j++) {
int r = 0;
do {
r = ToolBox.random(nrRooms);
} while (groupOfRooms[i].contains(rooms[r]));
groupOfRooms[i].add(rooms[r]);
groupForRoom[r].add(groupOfRooms[i]);
}
}
for (int i = 0; i < nrRooms; i++) {
int cnt = 0;
for (int j = 0; j < nrGroupsOfRooms; j++) if (groupOfRooms[j].contains(rooms[i]))
cnt++;
while (cnt < nrRoomInGroupMin) {
int r = 0;
do {
r = ToolBox.random(nrGroupsOfRooms);
} while (groupOfRooms[r].contains(rooms[i]));
groupOfRooms[r].add(rooms[i]);
groupForRoom[i].add(groupOfRooms[r]);
cnt++;
}
}
Resource[] instructors = new Resource[nrInstructors];
for (int i = 0; i < nrInstructors; i++) {
instructors[i] = new Resource("t" + (i + 1), Resource.TYPE_INSTRUCTOR, "Teacher " + (i + 1));
m.addConstraint(instructors[i]);
}
Resource[] classes = new Resource[nrClasses];
for (int i = 0; i < nrClasses; i++) {
classes[i] = new Resource("c" + (i + 1), Resource.TYPE_CLASS, "Class " + (i + 1));
m.addConstraint(classes[i]);
}
int[][] timetable4room = new int[nrRooms][nrSlots];
int[][] timetable4instr = new int[nrInstructors][nrSlots];
int[][] timetable4class = new int[nrClasses][nrSlots];
int act = 0;
for (int i = 0; i < timetable4room.length; i++) for (int j = 0; j < timetable4room[i].length; j++) timetable4room[i][j] = 0;
for (int i = 0; i < timetable4instr.length; i++) for (int j = 0; j < timetable4instr[i].length; j++) timetable4instr[i][j] = 0;
for (int i = 0; i < timetable4class.length; i++) for (int j = 0; j < timetable4class[i].length; j++) timetable4class[i][j] = 0;
int totalSlots = nrRooms * nrSlots;
int usedSlots = 0;
ArrayList<Integer> starts = new ArrayList<Integer>();
ArrayList<Integer> arooms = new ArrayList<Integer>();
while ((((double) usedSlots / ((double) totalSlots))) < fillFactor) {
int attempt = 0;
int slot = ToolBox.random(nrSlots);
int room = ToolBox.random(nrRooms);
while (attempt < 500 && timetable4room[room][slot] != 0) {
slot = ToolBox.random(nrSlots);
room = ToolBox.random(nrRooms);
}
if (attempt == 500) {
int s = slot;
int r = room;
while (timetable4room[r][s] != 0) {
r++;
if (r == nrRooms)
r = 0;
if (r == room)
s++;
if (s == nrSlots)
s = 0;
}
slot = s;
room = r;
}
// ToolBox.random(maxLength)+1;
int length = maxLength;
int aclass = ToolBox.random(nrClasses);
int instr = ToolBox.random(nrInstructors);
attempt = 0;
while (attempt < 500 && (timetable4class[aclass][slot] != 0 || timetable4instr[instr][slot] != 0)) {
aclass = ToolBox.random(nrClasses);
instr = ToolBox.random(nrInstructors);
}
if (attempt == 500)
continue;
int len = 1;
while (len < length) {
if ((((slot + len) % nrHours) != 0) && timetable4room[room][slot + len] == 0 && timetable4instr[instr][slot + len] == 0 && timetable4class[aclass][slot + len] == 0)
len++;
else
break;
}
ArrayList<Resource> roomGr = ToolBox.random(groupForRoom[room]);
act++;
usedSlots += len;
Activity a = new Activity(len, "a" + act, "Activity " + act);
a.addResourceGroup(roomGr);
a.addResourceGroup(instructors[instr]);
a.addResourceGroup(classes[aclass]);
m.addVariable(a);
starts.add(slot);
arooms.add(room);
for (int i = slot; i < slot + len; i++) {
timetable4room[room][i] = act;
timetable4instr[instr][i] = act;
timetable4class[aclass][i] = act;
}
}
int nrHardFreeRes = 0;
int nrSoftFreeRes = 0;
int nrSoftUsedRes = 0;
for (int slot = 0; slot < nrSlots; slot++) {
for (int room = 0; room < nrRooms; room++) {
if (timetable4room[room][slot] == 0) {
if (ToolBox.random() < hardFreeResource) {
nrHardFreeRes++;
rooms[room].addProhibitedSlot(slot);
} else if (ToolBox.random() < softFreeResource / (1.0 - hardFreeResource)) {
nrSoftFreeRes++;
rooms[room].addDiscouragedSlot(slot);
}
} else if (ToolBox.random() < softUsedResource) {
nrSoftUsedRes++;
rooms[room].addDiscouragedSlot(slot);
}
}
for (int instr = 0; instr < nrInstructors; instr++) {
if (timetable4instr[instr][slot] == 0) {
if (ToolBox.random() < hardFreeResource) {
nrHardFreeRes++;
instructors[instr].addProhibitedSlot(slot);
} else if (ToolBox.random() < softFreeResource / (1.0 - hardFreeResource)) {
nrSoftFreeRes++;
instructors[instr].addDiscouragedSlot(slot);
}
} else if (ToolBox.random() < softUsedResource) {
nrSoftUsedRes++;
instructors[instr].addDiscouragedSlot(slot);
}
}
for (int aclass = 0; aclass < nrClasses; aclass++) {
if (timetable4class[aclass][slot] == 0) {
if (ToolBox.random() < hardFreeResource) {
nrHardFreeRes++;
classes[aclass].addProhibitedSlot(slot);
} else if (ToolBox.random() < softFreeResource / (1.0 - hardFreeResource)) {
nrSoftFreeRes++;
classes[aclass].addDiscouragedSlot(slot);
}
} else if (ToolBox.random() < softUsedResource) {
nrSoftUsedRes++;
classes[aclass].addDiscouragedSlot(slot);
}
}
}
int nrSoftFreeAct = 0;
int nrSoftUsedAct = 0;
int nrHardFreeAct = 0;
for (int i = 0; i < m.variables().size(); i++) {
Activity activity = m.variables().get(i);
for (int slot = 0; slot < nrSlots; slot++) {
int start = starts.get(i);
if (slot < start || slot >= start + activity.getLength()) {
if (ToolBox.random() < hardFreeActivity) {
nrHardFreeAct++;
activity.addProhibitedSlot(slot);
} else if (ToolBox.random() < (softFreeActivity / (1.0 - hardFreeActivity))) {
nrSoftFreeAct++;
activity.addDiscouragedSlot(slot);
}
} else {
if (ToolBox.random() < softUsedActivity) {
nrSoftUsedAct++;
activity.addDiscouragedSlot(slot);
}
}
}
activity.init();
}
for (int i = 0; i < nrDependencies; ) {
int ac1 = ToolBox.random(m.variables().size());
int ac2 = ToolBox.random(m.variables().size());
while (ac1 == ac2) {
ac2 = ToolBox.random(m.variables().size());
}
int s1 = starts.get(ac1);
int s2 = starts.get(ac2);
Activity a1 = m.variables().get(ac1);
Activity a2 = m.variables().get(ac2);
Dependence dep = null;
if (s1 < s2) {
if (s1 + a1.getLength() == s2)
dep = new Dependence("d" + (i + 1), Dependence.TYPE_CLOSELY_BEFORE);
else if (s1 + a1.getLength() < s2)
dep = new Dependence("d" + (i + 1), Dependence.TYPE_BEFORE);
} else {
if (s2 == s1 + a1.getLength())
dep = new Dependence("d" + (i + 1), Dependence.TYPE_CLOSELY_AFTER);
else if (s2 > s1 + a1.getLength())
dep = new Dependence("d" + (i + 1), Dependence.TYPE_AFTER);
}
if (dep != null) {
dep.addVariable(a1);
dep.addVariable(a2);
m.addConstraint(dep);
i++;
}
}
for (int i = 0; i < m.variables().size(); i++) {
Activity activity = m.variables().get(i);
// sLogger.debug("-- processing activity "+activity.getName());
int start = starts.get(i);
int room = arooms.get(i);
Location location = null;
for (Location l : activity.values(assignment)) {
if (l.getSlot() == start && l.getResource(0).getResourceId().equals("r" + (room + 1))) {
location = l;
break;
}
}
if (location != null) {
Set<Location> conflicts = m.conflictValues(assignment, location);
if (!conflicts.isEmpty()) {
sLogger.warn("Unable to assign " + location.getName() + " to " + activity.getName() + ", reason:");
for (Constraint<Activity, Location> c : activity.constraints()) {
Set<Location> cc = new HashSet<Location>();
c.computeConflicts(assignment, location, cc);
if (!cc.isEmpty())
sLogger.warn(" -- Constraint " + c.getName() + " causes conflicts " + cc);
}
} else {
assignment.assign(0, location);
activity.setInitialAssignment(location);
}
// sLogger.debug(" -- location "+location.getName()+" found");
activity.setInitialAssignment(location);
} else {
sLogger.warn("Unable to assign " + activity.getName() + " -- no location matching slot=" + start + " room='R" + (room + 1) + "'");
}
}
if (!cfg.getPropertyBoolean("General.InitialAssignment", true)) {
for (int i = 0; i < m.variables().size(); i++) {
Activity activity = m.variables().get(i);
assignment.unassign(0, activity);
}
}
int forcedPerturbances = cfg.getPropertyInt("General.ForcedPerturbances", 0);
if (forcedPerturbances > 0) {
List<Activity> initialVariables = new ArrayList<Activity>();
for (Activity v : m.variables()) {
if (v.getInitialAssignment() != null)
initialVariables.add(v);
}
for (int i = 0; i < forcedPerturbances; i++) {
if (initialVariables.isEmpty())
break;
Activity var = ToolBox.random(initialVariables);
initialVariables.remove(var);
var.removeInitialValue();
}
}
sLogger.debug("-- Generator Info ---------------------------------------------------------");
sLogger.debug(" Total number of " + m.variables().size() + " activities generated.");
sLogger.debug(" Total number of " + usedSlots + " slots are filled (" + ((100.0 * usedSlots) / totalSlots) + "% filled).");
sLogger.debug(" Average length of an activity is " + (((double) usedSlots) / m.variables().size()));
sLogger.debug(" Total number of hard constraints posted on free slots on activities: " + nrHardFreeAct);
sLogger.debug(" Total number of soft constraints posted on free slots on activities: " + nrSoftFreeAct);
sLogger.debug(" Total number of soft constraints posted on used slots on activities: " + nrSoftUsedAct);
sLogger.debug(" Total number of hard constraints posted on free slots on resources: " + nrHardFreeRes);
sLogger.debug(" Total number of soft constraints posted on free slots on resources: " + nrSoftFreeRes);
sLogger.debug(" Total number of soft constraints posted on used slots on resources: " + nrSoftUsedRes);
sLogger.debug(" Total number of " + nrDependencies + " dependencies generated.");
sLogger.debug("---------------------------------------------------------------------------");
return m;
}
Also used :
ArrayList(java.util.ArrayList)
Constraint(org.cpsolver.ifs.model.Constraint)
HashSet(java.util.HashSet)
Aggregations
Constraint (org.cpsolver.ifs.model.Constraint)18
ArrayList (java.util.ArrayList)11
HashSet (java.util.HashSet)10
HashMap (java.util.HashMap)8
TreeSet (java.util.TreeSet)7
Lecture (org.cpsolver.coursett.model.Lecture)7
Placement (org.cpsolver.coursett.model.Placement)7
Element (org.dom4j.Element)7
Map (java.util.Map)6
Set (java.util.Set)6
BitSet (java.util.BitSet)4
List (java.util.List)4
GroupConstraint (org.cpsolver.coursett.constraint.GroupConstraint)4
InstructorConstraint (org.cpsolver.coursett.constraint.InstructorConstraint)4
RoomConstraint (org.cpsolver.coursett.constraint.RoomConstraint)4
SpreadConstraint (org.cpsolver.coursett.constraint.SpreadConstraint)4
RoomLocation (org.cpsolver.coursett.model.RoomLocation)4
Student (org.cpsolver.coursett.model.Student)4
FileWriter (java.io.FileWriter)3
PrintWriter (java.io.PrintWriter)3
