Examples with Config org.cpsolver.studentsct.model.Config used on opensource projects

Example 26 with Config

use of org.cpsolver.studentsct.model.Config in project cpsolver by UniTime.

the class RequiredReservation method inConflict.

/**
     * A given enrollment is conflicting, if there is a reservation that
     * the student must use, but the given enrollment does not use it.
     * 
     * @param enrollment {@link Enrollment} that is being considered
     * @return true, if the enrollment does not follow a reservation that must be used 
     */
@Override
public boolean inConflict(Assignment<Request, Enrollment> assignment, Enrollment enrollment) {
    // enrollment's config
    Config config = enrollment.getConfig();
    // exclude free time requests
    if (config == null)
        return false;
    // no reservations
    if (!config.getOffering().hasReservations())
        return false;
    // enrollment's reservation
    Reservation reservation = enrollment.getReservation();
    // already has a reservation that must be used
    if (reservation != null && reservation.mustBeUsed())
        return false;
    // if a reservation is required for the student, fail
    for (Reservation r : config.getOffering().getReservations()) if (r.mustBeUsed() && r.isApplicable(enrollment.getStudent()))
        return true;
    return false;
}

Example 27 with Config

use of org.cpsolver.studentsct.model.Config in project cpsolver by UniTime.

the class StudentPreferencePenalties method setPenalties.

/**
     * Set the computed penalties to all sections of all requests of the given
     * student
     * @param student given student
     * @param distributionType penalty distribution type
     */
public static void setPenalties(Student student, int distributionType) {
    if (sDebug)
        sLog.debug("Setting penalties for " + student);
    StudentPreferencePenalties penalties = new StudentPreferencePenalties(distributionType);
    for (Request request : student.getRequests()) {
        if (!(request instanceof CourseRequest))
            continue;
        CourseRequest courseRequest = (CourseRequest) request;
        if (sDebug)
            sLog.debug("-- " + courseRequest);
        for (Course course : courseRequest.getCourses()) {
            if (sDebug)
                sLog.debug("  -- " + course.getName());
            for (Config config : course.getOffering().getConfigs()) {
                if (sDebug)
                    sLog.debug("    -- " + config.getName());
                for (Subpart subpart : config.getSubparts()) {
                    if (sDebug)
                        sLog.debug("      -- " + subpart.getName());
                    for (Section section : subpart.getSections()) {
                        section.setPenalty(penalties.getPenalty(section));
                        if (sDebug)
                            sLog.debug("        -- " + section);
                    }
                }
            }
        }
        courseRequest.clearCache();
    }
}

Example 28 with Config

use of org.cpsolver.studentsct.model.Config in project cpsolver by UniTime.

the class Test method clone.

protected Course clone(Course course, long studentId, Student originalStudent, Map<Long, Section> classTable, StudentSectioningModel model) {
    Offering clonedOffering = new Offering(course.getOffering().getId(), course.getOffering().getName());
    clonedOffering.setModel(model);
    int courseLimit = course.getLimit();
    if (courseLimit >= 0) {
        courseLimit -= course.getEnrollments(assignment()).size();
        if (courseLimit < 0)
            courseLimit = 0;
        for (Iterator<Enrollment> i = course.getEnrollments(assignment()).iterator(); i.hasNext(); ) {
            Enrollment enrollment = i.next();
            if (enrollment.getStudent().getId() == studentId) {
                courseLimit++;
                break;
            }
        }
    }
    Course clonedCourse = new Course(course.getId(), course.getSubjectArea(), course.getCourseNumber(), clonedOffering, courseLimit, course.getProjected());
    clonedCourse.setNote(course.getNote());
    Hashtable<Config, Config> configs = new Hashtable<Config, Config>();
    Hashtable<Subpart, Subpart> subparts = new Hashtable<Subpart, Subpart>();
    Hashtable<Section, Section> sections = new Hashtable<Section, Section>();
    for (Iterator<Config> e = course.getOffering().getConfigs().iterator(); e.hasNext(); ) {
        Config config = e.next();
        int configLimit = config.getLimit();
        int configEnrollment = config.getEnrollments(assignment()).size();
        if (configLimit >= 0) {
            configLimit -= config.getEnrollments(assignment()).size();
            if (configLimit < 0)
                configLimit = 0;
            for (Iterator<Enrollment> i = config.getEnrollments(assignment()).iterator(); i.hasNext(); ) {
                Enrollment enrollment = i.next();
                if (enrollment.getStudent().getId() == studentId) {
                    configLimit++;
                    configEnrollment--;
                    break;
                }
            }
        }
        OnlineConfig clonedConfig = new OnlineConfig(config.getId(), configLimit, config.getName(), clonedOffering);
        clonedConfig.setInstructionalMethodId(config.getInstructionalMethodId());
        clonedConfig.setInstructionalMethodName(config.getInstructionalMethodName());
        clonedConfig.setEnrollment(configEnrollment);
        configs.put(config, clonedConfig);
        for (Iterator<Subpart> f = config.getSubparts().iterator(); f.hasNext(); ) {
            Subpart subpart = f.next();
            Subpart clonedSubpart = new Subpart(subpart.getId(), subpart.getInstructionalType(), subpart.getName(), clonedConfig, (subpart.getParent() == null ? null : subparts.get(subpart.getParent())));
            clonedSubpart.setAllowOverlap(subpart.isAllowOverlap());
            clonedSubpart.setCredit(subpart.getCredit());
            subparts.put(subpart, clonedSubpart);
            for (Iterator<Section> g = subpart.getSections().iterator(); g.hasNext(); ) {
                Section section = g.next();
                int limit = section.getLimit();
                int enrl = section.getEnrollments(assignment()).size();
                if (limit >= 0) {
                    // limited section, deduct enrollments
                    limit -= section.getEnrollments(assignment()).size();
                    if (limit < 0)
                        // over-enrolled, but not unlimited
                        limit = 0;
                    if (studentId >= 0)
                        for (Enrollment enrollment : section.getEnrollments(assignment())) if (enrollment.getStudent().getId() == studentId) {
                            limit++;
                            enrl--;
                            break;
                        }
                }
                OnlineSection clonedSection = new OnlineSection(section.getId(), limit, section.getName(course.getId()), clonedSubpart, section.getPlacement(), section.getInstructors(), (section.getParent() == null ? null : sections.get(section.getParent())));
                clonedSection.setName(-1l, section.getName(-1l));
                clonedSection.setNote(section.getNote());
                clonedSection.setSpaceExpected(section.getSpaceExpected());
                clonedSection.setSpaceHeld(section.getSpaceHeld());
                clonedSection.setEnrollment(enrl);
                clonedSection.setCancelled(section.isCancelled());
                if (section.getIgnoreConflictWithSectionIds() != null)
                    for (Long id : section.getIgnoreConflictWithSectionIds()) clonedSection.addIgnoreConflictWith(id);
                if (limit > 0) {
                    double available = Math.round(section.getSpaceExpected() - limit);
                    clonedSection.setPenalty(available / section.getLimit());
                }
                sections.put(section, clonedSection);
                classTable.put(section.getId(), clonedSection);
            }
        }
    }
    if (course.getOffering().hasReservations()) {
        for (Reservation reservation : course.getOffering().getReservations()) {
            int reservationLimit = (int) Math.round(reservation.getLimit());
            if (reservationLimit >= 0) {
                reservationLimit -= reservation.getEnrollments(assignment()).size();
                if (reservationLimit < 0)
                    reservationLimit = 0;
                for (Iterator<Enrollment> i = reservation.getEnrollments(assignment()).iterator(); i.hasNext(); ) {
                    Enrollment enrollment = i.next();
                    if (enrollment.getStudent().getId() == studentId) {
                        reservationLimit++;
                        break;
                    }
                }
                if (reservationLimit <= 0 && !reservation.mustBeUsed())
                    continue;
            }
            boolean applicable = originalStudent != null && reservation.isApplicable(originalStudent);
            if (reservation instanceof CourseReservation)
                applicable = (course.getId() == ((CourseReservation) reservation).getCourse().getId());
            if (reservation instanceof org.cpsolver.studentsct.reservation.DummyReservation) {
                // the student is already enrolled in the course
                for (Enrollment enrollment : course.getEnrollments(assignment())) if (enrollment.getStudent().getId() == studentId) {
                    applicable = true;
                    break;
                }
            }
            Reservation clonedReservation = new OnlineReservation(0, reservation.getId(), clonedOffering, reservation.getPriority(), reservation.canAssignOverLimit(), reservationLimit, applicable, reservation.mustBeUsed(), reservation.isAllowOverlap(), reservation.isExpired());
            for (Config config : reservation.getConfigs()) clonedReservation.addConfig(configs.get(config));
            for (Map.Entry<Subpart, Set<Section>> entry : reservation.getSections().entrySet()) {
                Set<Section> clonedSections = new HashSet<Section>();
                for (Section section : entry.getValue()) clonedSections.add(sections.get(section));
                clonedReservation.getSections().put(subparts.get(entry.getKey()), clonedSections);
            }
        }
    }
    return clonedCourse;
}

Example 29 with Config

use of org.cpsolver.studentsct.model.Config in project cpsolver by UniTime.

the class ReservationLimit method computeConflicts.

/**
     * A given enrollment is conflicting, if the reservation's remaining available space
     * (computed by {@link Reservation#getReservedAvailableSpace(Assignment, Request)})
     * is below the requests weight {@link Request#getWeight()}. <br>
     * If the limit is breached, one or more existing enrollments are
     * selected as conflicting until there is enough space in the reservation.
     * Similarly, if the enrollment does not have the reservation, it is checked
     * that there is enough unreserved space in the desired configuration.
     * 
     * @param enrollment
     *            {@link Enrollment} that is being considered
     * @param conflicts
     *            all computed conflicting requests are added into this set
     */
@Override
public void computeConflicts(Assignment<Request, Enrollment> assignment, Enrollment enrollment, Set<Enrollment> conflicts) {
    // enrollment's config
    Config config = enrollment.getConfig();
    // exclude free time requests
    if (config == null)
        return;
    // no reservations
    if (!config.getOffering().hasReservations())
        return;
    // enrollment's reservation
    Reservation reservation = enrollment.getReservation();
    // check space in the reservation reservation
    if (reservation != null) {
        // check reservation too
        double reserved = reservation.getReservedAvailableSpace(assignment, enrollment.getRequest());
        if (reservation.getLimit() >= 0 && reserved < enrollment.getRequest().getWeight()) {
            // reservation is not unlimited and there is not enough space in it
            // try to free some space in the reservation
            List<Enrollment> adepts = new ArrayList<Enrollment>(config.getEnrollments(assignment).size());
            for (Enrollment e : config.getEnrollments(assignment)) {
                if (e.getRequest().equals(enrollment.getRequest()))
                    continue;
                if (!reservation.equals(e.getReservation()))
                    continue;
                if (conflicts.contains(e))
                    reserved += e.getRequest().getWeight();
                else
                    adepts.add(e);
            }
            while (reserved < enrollment.getRequest().getWeight()) {
                if (adepts.isEmpty()) {
                    // no adepts -> enrollment cannot be assigned
                    conflicts.add(enrollment);
                    return;
                }
                // pick adept (prefer dummy students), decrease unreserved space,
                // make conflict
                List<Enrollment> best = new ArrayList<Enrollment>();
                boolean bestDummy = false;
                double bestValue = 0;
                for (Enrollment adept : adepts) {
                    boolean dummy = adept.getStudent().isDummy();
                    double value = adept.toDouble(assignment, false);
                    if (iPreferDummyStudents && dummy != bestDummy) {
                        if (dummy) {
                            best.clear();
                            best.add(adept);
                            bestDummy = dummy;
                            bestValue = value;
                        }
                        continue;
                    }
                    if (best.isEmpty() || value > bestValue) {
                        if (best.isEmpty())
                            best.clear();
                        best.add(adept);
                        bestDummy = dummy;
                        bestValue = value;
                    } else if (bestValue == value) {
                        best.add(adept);
                    }
                }
                Enrollment conflict = ToolBox.random(best);
                adepts.remove(conflict);
                reserved += conflict.getRequest().getWeight();
                conflicts.add(conflict);
            }
        }
        // if not configuration reservation -> check configuration unavailable space
        if (!hasConfigReservation(enrollment)) {
            // check reservation can assign over the limit
            if (reservation.canBatchAssignOverLimit())
                return;
            // the section for an enrollment w/o configuration reservation
            if (config.getTotalUnreservedSpace() < enrollment.getRequest().getWeight()) {
                conflicts.add(enrollment);
                return;
            }
            double unreserved = getUnreservedSpace(assignment, config, enrollment.getRequest(), true);
            if (unreserved < 0.0) {
                // no unreserved space available -> cannot be assigned
                // try to unassign some other enrollments that also do not have config reservation
                List<Enrollment> adepts = new ArrayList<Enrollment>(config.getEnrollments(assignment).size());
                for (Enrollment e : config.getEnrollments(assignment)) {
                    if (e.getRequest().equals(enrollment.getRequest()))
                        continue;
                    if (hasConfigReservation(e))
                        continue;
                    if (conflicts.contains(e))
                        unreserved += e.getRequest().getWeight();
                    else
                        adepts.add(e);
                }
                while (unreserved < 0.0) {
                    if (adepts.isEmpty()) {
                        // no adepts -> enrollment cannot be assigned
                        conflicts.add(enrollment);
                        return;
                    }
                    // pick adept (prefer dummy students), decrease unreserved space,
                    // make conflict
                    List<Enrollment> best = new ArrayList<Enrollment>();
                    boolean bestDummy = false;
                    double bestValue = 0;
                    for (Enrollment adept : adepts) {
                        boolean dummy = adept.getStudent().isDummy();
                        double value = adept.toDouble(assignment, false);
                        if (iPreferDummyStudents && dummy != bestDummy) {
                            if (dummy) {
                                best.clear();
                                best.add(adept);
                                bestDummy = dummy;
                                bestValue = value;
                            }
                            continue;
                        }
                        if (best.isEmpty() || value > bestValue) {
                            if (best.isEmpty())
                                best.clear();
                            best.add(adept);
                            bestDummy = dummy;
                            bestValue = value;
                        } else if (bestValue == value) {
                            best.add(adept);
                        }
                    }
                    Enrollment conflict = ToolBox.random(best);
                    adepts.remove(conflict);
                    unreserved += conflict.getRequest().getWeight();
                    conflicts.add(conflict);
                }
            }
        }
    } else {
        // the section for an enrollment w/o reservation
        if (config.getOffering().getTotalUnreservedSpace() < enrollment.getRequest().getWeight() || config.getTotalUnreservedSpace() < enrollment.getRequest().getWeight()) {
            conflicts.add(enrollment);
            return;
        }
        // check configuration unavailable space too
        double unreserved = getUnreservedSpace(assignment, config, enrollment.getRequest(), false);
        if (unreserved < 0.0) {
            // no unreserved space available -> cannot be assigned
            // try to unassign some other enrollments that also do not have reservation
            List<Enrollment> adepts = new ArrayList<Enrollment>(config.getEnrollments(assignment).size());
            for (Enrollment e : config.getEnrollments(assignment)) {
                if (e.getRequest().equals(enrollment.getRequest()))
                    continue;
                if (e.getReservation() != null)
                    continue;
                if (conflicts.contains(e))
                    unreserved += e.getRequest().getWeight();
                else
                    adepts.add(e);
            }
            while (unreserved < 0.0) {
                if (adepts.isEmpty()) {
                    // no adepts -> enrollment cannot be assigned
                    conflicts.add(enrollment);
                    return;
                }
                // pick adept (prefer dummy students), decrease unreserved space,
                // make conflict
                List<Enrollment> best = new ArrayList<Enrollment>();
                boolean bestDummy = false;
                double bestValue = 0;
                for (Enrollment adept : adepts) {
                    boolean dummy = adept.getStudent().isDummy();
                    double value = adept.toDouble(assignment, false);
                    if (iPreferDummyStudents && dummy != bestDummy) {
                        if (dummy) {
                            best.clear();
                            best.add(adept);
                            bestDummy = dummy;
                            bestValue = value;
                        }
                        continue;
                    }
                    if (best.isEmpty() || value > bestValue) {
                        if (best.isEmpty())
                            best.clear();
                        best.add(adept);
                        bestDummy = dummy;
                        bestValue = value;
                    } else if (bestValue == value) {
                        best.add(adept);
                    }
                }
                Enrollment conflict = ToolBox.random(best);
                adepts.remove(conflict);
                unreserved += conflict.getRequest().getWeight();
                conflicts.add(conflict);
            }
        }
    }
}

Example 30 with Config

use of org.cpsolver.studentsct.model.Config in project cpsolver by UniTime.

the class ReservationLimit method inConflict.

/**
     * A given enrollment is conflicting, if the config's enrollment (computed by
     * {@link ConfigLimit#getEnrollmentWeight(Assignment, Config, Request)}) exceeds the
     * limit.
     * 
     * @param enrollment
     *            {@link Enrollment} that is being considered
     * @return true, if the enrollment cannot be assigned without exceeding the limit
     */
@Override
public boolean inConflict(Assignment<Request, Enrollment> assignment, Enrollment enrollment) {
    // enrollment's config
    Config config = enrollment.getConfig();
    // exclude free time requests
    if (config == null)
        return false;
    // enrollment's reservation
    Reservation reservation = enrollment.getReservation();
    // check reservation
    if (reservation != null) {
        // unlimited reservation
        if (reservation.getLimit() < 0)
            return false;
        // check remaning space
        if (reservation.getReservedAvailableSpace(assignment, enrollment.getRequest()) < enrollment.getRequest().getWeight())
            return true;
        // check reservation can assign over the limit
        if (reservation.canBatchAssignOverLimit())
            return false;
        // if not configuration reservation, check configuration unreserved space too
        return (!hasConfigReservation(enrollment) && getUnreservedSpace(assignment, config, enrollment.getRequest(), true) < 0.0);
    } else {
        // check unreserved space;
        return config.getOffering().getTotalUnreservedSpace() < enrollment.getRequest().getWeight() || config.getTotalUnreservedSpace() < enrollment.getRequest().getWeight() || getUnreservedSpace(assignment, config, enrollment.getRequest(), false) < 0.0;
    }
}