001package org.cpsolver.exam.criteria; 002 003import java.util.Collection; 004import java.util.Map; 005import java.util.Set; 006 007import org.cpsolver.exam.model.Exam; 008import org.cpsolver.exam.model.ExamInstructor; 009import org.cpsolver.exam.model.ExamModel; 010import org.cpsolver.exam.model.ExamPeriod; 011import org.cpsolver.exam.model.ExamPlacement; 012import org.cpsolver.ifs.assignment.Assignment; 013import org.cpsolver.ifs.util.DataProperties; 014 015 016/** 017 * Number of direct instructor conflicts. I.e., number of cases when an 018 * exam is attended by an instructor that attends some other exam at the 019 * same period. 020 * <br><br> 021 * Direct instructor conflict weight can be set by problem property 022 * Exams.InstructorDirectConflictWeight, or in the input xml file, property 023 * instructorDirectConflictWeight. 024 * 025 * <br> 026 * 027 * @version ExamTT 1.3 (Examination Timetabling)<br> 028 * Copyright (C) 2008 - 2014 Tomáš Müller<br> 029 * <a href="mailto:muller@unitime.org">muller@unitime.org</a><br> 030 * <a href="http://muller.unitime.org">http://muller.unitime.org</a><br> 031 * <br> 032 * This library is free software; you can redistribute it and/or modify 033 * it under the terms of the GNU Lesser General Public License as 034 * published by the Free Software Foundation; either version 3 of the 035 * License, or (at your option) any later version. <br> 036 * <br> 037 * This library is distributed in the hope that it will be useful, but 038 * WITHOUT ANY WARRANTY; without even the implied warranty of 039 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 040 * Lesser General Public License for more details. <br> 041 * <br> 042 * You should have received a copy of the GNU Lesser General Public 043 * License along with this library; if not see 044 * <a href='http://www.gnu.org/licenses/'>http://www.gnu.org/licenses/</a>. 045 */ 046public class InstructorDirectConflicts extends StudentDirectConflicts { 047 048 @Override 049 public String getWeightName() { 050 return "Exams.InstructorDirectConflictWeight"; 051 } 052 053 @Override 054 public String getXmlWeightName() { 055 return "instructorDirectConflictWeight"; 056 } 057 058 @Override 059 public double getWeightDefault(DataProperties config) { 060 return 1000.0; 061 } 062 063 @Override 064 public double getValue(Assignment<Exam, ExamPlacement> assignment, ExamPlacement value, Set<ExamPlacement> conflicts) { 065 Exam exam = value.variable(); 066 int penalty = 0; 067 ExamPeriod period = value.getPeriod(); 068 ExamModel m = (ExamModel)getModel(); 069 Map<ExamInstructor, Set<Exam>> instructors = m.getInstructorsOfPeriod(assignment, period); 070 for (ExamInstructor s : exam.getInstructors()) { 071 Set<Exam> exams = instructors.get(s); 072 if (exams == null) continue; 073 int nrExams = exams.size() + (exams.contains(exam) ? 0 : 1); 074 if (nrExams > 1) 075 penalty++; 076 } 077 if (m.isCheckForPeriodOverlaps()) { 078 for (ExamPeriod p: m.getPeriods()) { 079 if (period.hasIntersection(p)) { 080 Map<ExamInstructor, Set<Exam>> others = m.getInstructorsOfPeriod(assignment, p); 081 s: for (ExamInstructor s : exam.getInstructors()) { 082 Set<Exam> exams = instructors.get(s); 083 if (exams == null || exams.size() + (exams.contains(exam) ? 0 : 1) <= 1) { 084 Set<Exam> other = others.get(s); 085 if (other != null && !other.isEmpty()) 086 for (Exam x: other) { 087 if (period.hasIntersection(exam, x, p)) { 088 penalty ++; continue s; 089 } 090 } 091 } 092 } 093 } 094 } 095 } 096 /* 097 for (ExamInstructor s : exam.getInstructors()) { 098 Set<Exam> exams = s.getExams(assignment, value.getPeriod()); 099 int nrExams = exams.size() + (exams.contains(exam) ? 0 : 1); 100 if (nrExams > 1) 101 penalty++; 102 } 103 */ 104 return penalty; 105 } 106 107 @Override 108 public double getValue(Assignment<Exam, ExamPlacement> assignment, Collection<Exam> variables) { 109 int ret = 0; 110 ExamModel m = (ExamModel)getModel(); 111 for (ExamPeriod p: m.getPeriods()) { 112 Map<ExamInstructor, Set<Exam>> instructors = m.getInstructorsOfPeriod(assignment, p); 113 for (Set<Exam> exams: instructors.values()) { 114 int nrExams = exams.size(); 115 if (nrExams > 1) 116 ret += nrExams - 1; 117 } 118 } 119 if (m.isCheckForPeriodOverlaps()) { 120 for (ExamPeriod p: m.getPeriods()) { 121 for (ExamPeriod q: m.getPeriods()) { 122 if (p.getIndex() < q.getIndex() && p.hasIntersection(q)) { 123 Map<ExamInstructor, Set<Exam>> s1 = m.getInstructorsOfPeriod(assignment, p); 124 Map<ExamInstructor, Set<Exam>> s2 = m.getInstructorsOfPeriod(assignment, q); 125 for (Map.Entry<ExamInstructor, Set<Exam>> e: s1.entrySet()) { 126 ExamInstructor s = e.getKey(); 127 if (!e.getValue().isEmpty()) { 128 Set<Exam> x = s2.get(s); 129 if (x != null && x.isEmpty()) { 130 x1: for (Exam x1: e.getValue()) { 131 for (Exam x2: x) { 132 if (p.hasIntersection(x1, x2, q)) { 133 ret += 1; break x1; 134 } 135 } 136 } 137 } 138 } 139 } 140 } 141 } 142 } 143 } 144 return ret; 145 } 146 147 @Override 148 public String getName() { 149 return "Instructor Direct Conflicts"; 150 } 151 152 @Override 153 public void getInfo(Assignment<Exam, ExamPlacement> assignment, Map<String, String> info) { 154 InstructorNotAvailableConflicts na = (InstructorNotAvailableConflicts)getModel().getCriterion(InstructorNotAvailableConflicts.class); 155 if (getValue(assignment) != 0.0 || (na != null && na.getValue(assignment) != 0.0)) 156 info.put(getName(), sDoubleFormat.format(getValue(assignment) + (na == null ? 0.0 : na.getValue(assignment))) + 157 (na == null || na.getValue(assignment) == 0.0 ? "" : " (" + sDoubleFormat.format(na.getValue(assignment)) + " N/A)")); 158 } 159 160 @Override 161 public String toString(Assignment<Exam, ExamPlacement> assignment) { 162 return "iDC:" + sDoubleFormat.format(getValue(assignment)); 163 } 164}