canvas-lms/lib/grade_calculator.rb

#
# Copyright (C) 2011 - 2014 Instructure, Inc.
#
# This file is part of Canvas.
#
# Canvas is free software: you can redistribute it and/or modify it under
# the terms of the GNU Affero General Public License as published by the Free
# Software Foundation, version 3 of the License.
#
# Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
#

class GradeCalculator
  attr_accessor :submissions, :assignments, :groups

  def initialize(user_ids, course, opts = {})
    opts = opts.reverse_merge(:ignore_muted => true)

    Rails.logger.info("GRADES: calc args: user_ids=#{user_ids.inspect}")
    Rails.logger.info("GRADES: calc args: course=#{course.inspect}")
    Rails.logger.info("GRADES: calc args: opts=#{opts.inspect}")

    @course = course.is_a?(Course) ? course : Course.find(course)
    @groups = @course.assignment_groups.active
    @grading_period = opts[:grading_period]

    assignment_scope = @course.assignments.published.gradeable
    @assignments = assignment_scope.to_a

    @user_ids = Array(user_ids).map(&:to_i)
    @current_updates = {}
    @final_updates = {}
    @ignore_muted = opts[:ignore_muted]
  end

  # recomputes the scores and saves them to each user's Enrollment
  def self.recompute_final_score(user_ids, course_id)
    user_ids = Array(user_ids).uniq.map(&:to_i)
    return if user_ids.empty?
    user_ids.in_groups_of(1000, false) do |user_ids_group|
      calc = GradeCalculator.new user_ids_group, course_id
      calc.compute_and_save_scores
    end
  end

  def compute_scores
    @submissions = @course.submissions.
        except(:order, :select).
        for_user(@user_ids).
        where(assignment_id: @assignments.map(&:id)).
        select("submissions.id, user_id, assignment_id, score, excused")
    submissions_by_user = @submissions.group_by(&:user_id)

    scores = []
    @user_ids.each_slice(100) do |batched_ids|
      load_assignment_visibilities_for_users(batched_ids)
      batched_ids.each do |user_id|
        user_submissions = submissions_by_user[user_id] || []
        if differentiated_assignments_on?
          user_submissions.select!{|s| assignment_ids_visible_to_user(user_id).include?(s.assignment_id)}
        end
        current, current_groups = calculate_current_score(user_id, user_submissions)
        final, final_groups = calculate_final_score(user_id, user_submissions)
        scores << [[current, current_groups], [final, final_groups]]
      end
      clear_assignment_visibilities_cache
    end
    scores
  end

  def compute_and_save_scores
    compute_scores
    save_scores
  end

  private

  def differentiated_assignments_on?
    @differentiated_assignments_enabled ||= @course.feature_enabled?(:differentiated_assignments)
  end

  def save_scores
    raise "Can't save scores when ignore_muted is false" unless @ignore_muted

    Course.where(:id => @course).update_all(:updated_at => Time.now.utc)
    time = Enrollment.sanitize(Time.now.utc)
    query = "updated_at=#{time}, graded_at=#{time}"
    query += ", computed_current_score=CASE user_id #{@current_updates.map { |user_id, grade| "WHEN #{user_id} THEN #{grade || "NULL"}"}.
      join(" ")} ELSE computed_current_score END"
    query += ", computed_final_score=CASE user_id #{@final_updates.map { |user_id, grade| "WHEN #{user_id} THEN #{grade || "NULL"}"}.
      join(" ")} ELSE computed_final_score END"
    Enrollment.where(:user_id => @user_ids, :course_id => @course).update_all(query)
  end

  # The score ignoring unsubmitted assignments
  def calculate_current_score(user_id, submissions)
    calculate_score(submissions, user_id, @current_updates, true)
  end

  # The final score for the class, so unsubmitted assignments count as zeros
  def calculate_final_score(user_id, submissions)
    calculate_score(submissions, user_id, @final_updates, false)
  end

  def calculate_score(submissions, user_id, grade_updates, ignore_ungraded)
    group_sums = create_group_sums(submissions, user_id, ignore_ungraded)
    info = calculate_total_from_group_scores(group_sums)
    Rails.logger.info "GRADES: calculated: #{info.inspect}"
    grade_updates[user_id] = info[:grade]
    [info, group_sums.index_by { |s| s[:id] }]
  end

  # returns information about assignments groups in the form:
  # [
  #   {
  #    :id       => 1
  #    :score    => 5,
  #    :possible => 7,
  #    :grade    => 71.42,
  #    :weight   => 50},
  #   ...]
  # each group
  def create_group_sums(submissions, user_id, ignore_ungraded=true)
    visible_assignments = @assignments
    if differentiated_assignments_on?
      visible_assignments = visible_assignments.select{|a| assignment_ids_visible_to_user(user_id).include?(a.id)}
    end

    if @grading_period
      user = @course.users.find(user_id)
      visible_assignments = @grading_period.assignments_for_student(visible_assignments, user)
    end
    assignments_by_group_id = visible_assignments.group_by(&:assignment_group_id)
    submissions_by_assignment_id = Hash[
      submissions.map { |s| [s.assignment_id, s] }
    ]

    @groups.map do |group|
      assignments = assignments_by_group_id[group.id] || []

      group_submissions = assignments.map do |a|
        s = submissions_by_assignment_id[a.id]

        # ignore submissions for muted assignments
        s = nil if @ignore_muted && a.muted?

        {
          assignment: a,
          submission: s,
          score: s && s.score,
          total: a.points_possible || 0,
          excused: s && s.excused?,
        }
      end

      group_submissions.reject! { |s| s[:score].nil? } if ignore_ungraded
      group_submissions.reject! { |s| s[:excused] }
      group_submissions.each { |s| s[:score] ||= 0 }

      logged_submissions = group_submissions.map { |s| loggable_submission(s) }
      Rails.logger.info "GRADES: calculating for assignment_group=#{group.global_id} user=#{user_id}"
      Rails.logger.info "GRADES: calculating... ignore_ungraded=#{ignore_ungraded}"
      Rails.logger.info "GRADES: calculating... submissions=#{logged_submissions.inspect}"

      kept = drop_assignments(group_submissions, group.rules_hash)

      score, possible = kept.reduce([0, 0]) { |(s_sum,p_sum),s|
        [s_sum + s[:score], p_sum + s[:total]]
      }

      {
        :id       => group.id,
        :score    => score,
        :possible => possible,
        :weight   => group.group_weight,
        :grade    => ((score.to_f / possible * 100).round(2) if possible > 0),
      }.tap { |group_grade_info|
        Rails.logger.info "GRADES: calculated #{group_grade_info.inspect}"
      }
    end
  end

  def load_assignment_visibilities_for_users(user_ids)
    @assignment_ids_visible_to_user ||= begin
      if differentiated_assignments_on?
        AssignmentStudentVisibility.visible_assignment_ids_in_course_by_user(course_id: @course.id, user_id: user_ids)
      else
        assignment_ids = @assignments.map(&:id)
        user_ids.reduce({}){|hash, id| hash[id] = assignment_ids; hash}
      end
    end
  end

  def clear_assignment_visibilities_cache
    @assignment_ids_visible_to_user = nil
  end

  def assignment_ids_visible_to_user(user_id)
    @assignment_ids_visible_to_user[user_id]
  end

  # see comments for dropAssignments in grade_calculator.coffee
  def drop_assignments(submissions, rules)
    drop_lowest    = rules[:drop_lowest] || 0
    drop_highest   = rules[:drop_highest] || 0
    never_drop_ids = rules[:never_drop] || []
    return submissions if drop_lowest.zero? && drop_highest.zero?

    Rails.logger.info "GRADES: dropping assignments! #{rules.inspect}"

    cant_drop = []
    if never_drop_ids.present?
      cant_drop, submissions = submissions.partition { |s|
        never_drop_ids.include? s[:assignment].id
      }
    end

    # fudge the drop rules if there aren't enough submissions
    return cant_drop if submissions.empty?
    drop_lowest = submissions.size - 1 if drop_lowest >= submissions.size
    drop_highest = 0 if drop_lowest + drop_highest >= submissions.size

    keep_highest = submissions.size - drop_lowest
    keep_lowest  = keep_highest - drop_highest

    submissions.sort! { |a,b| a[:assignment].id - b[:assignment].id }

    # assignment groups that have no points possible have to be dropped
    # differently (it's a simpler case, but not one that fits in with our
    # usual bisection approach)
    kept = (cant_drop + submissions).any? { |s| s[:total] > 0 } ?
      drop_pointed(submissions, cant_drop, keep_highest, keep_lowest) :
      drop_unpointed(submissions, keep_highest, keep_lowest)

    (kept + cant_drop).tap do |all_kept|
      loggable_kept = all_kept.map { |s| loggable_submission(s) }
      Rails.logger.info "GRADES.calculating... kept=#{loggable_kept.inspect}"
    end
  end

  def drop_unpointed(submissions, keep_highest, keep_lowest)
    sorted_submissions = submissions.sort_by { |s| s[:score] }
    sorted_submissions.last(keep_highest).first(keep_lowest)
  end

  def drop_pointed(submissions, cant_drop, n_highest, n_lowest)
    max_total = (submissions + cant_drop).map { |s| s[:total] }.max

    kept = keep_highest(submissions, cant_drop, n_highest, max_total)
    kept = keep_lowest(kept, cant_drop, n_lowest, max_total)
  end

  def keep_highest(submissions, cant_drop, keep, max_total)
    keep_helper(submissions, cant_drop, keep, max_total) { |*args| big_f_best(*args) }
  end

  def keep_lowest(submissions, cant_drop, keep, max_total)
    keep_helper(submissions, cant_drop, keep, max_total) { |*args| big_f_worst(*args) }
  end

  # @submissions: set of droppable submissions
  # @cant_drop: submissions that are not eligible for dropping
  # @keep: number of submissions to keep from +submissions+
  # @max_total: the highest number of points possible
  # @big_f_blk: sorting block for the big_f function
  # returns +keep+ +submissions+
  def keep_helper(submissions, cant_drop, keep, max_total, &big_f_blk)
    return submissions if submissions.size <= keep

    unpointed, pointed = (submissions + cant_drop).partition { |s|
      s[:total].zero?
    }
    grades = pointed.map { |s| s[:score].to_f / s[:total] }.sort

    q_high = estimate_q_high(pointed, unpointed, grades)
    q_low  = grades.first
    q_mid  = (q_low + q_high) / 2

    x, kept = big_f_blk.call(q_mid, submissions, cant_drop, keep)
    threshold = 1 / (2 * keep * max_total**2)
    until q_high - q_low < threshold
      x < 0 ?
        q_high = q_mid :
        q_low  = q_mid
      q_mid = (q_low + q_high) / 2

      # bail if we can't can't ever satisfy the threshold (floats!)
      break if q_mid == q_high || q_mid == q_low

      x, kept = big_f_blk.call(q_mid, submissions, cant_drop, keep)
    end

    kept
  end

  def big_f(q, submissions, cant_drop, keep, &sort_blk)
    kept = submissions.map { |s|
      rated_score = s[:score] - q * s[:total]
      [rated_score, s]
    }.sort(&sort_blk).first(keep)

    q_kept = kept.reduce(0) { |sum,(rated_score,_)| sum + rated_score }
    q_cant_drop = cant_drop.reduce(0) { |sum,s| sum + (s[:score] - q * s[:total]) }

    [q_kept + q_cant_drop, kept.map(&:last)]
  end

  # we can't use the student's highest grade as an upper-bound for bisection
  # when 0-points-possible assignments are present, so guess the best possible
  # grade the student could have earned in that case
  def estimate_q_high(pointed, unpointed, grades)
    if unpointed.present?
      points_possible = pointed.reduce(0) { |sum,s| sum + s[:total] }
      best_pointed_score = [
        points_possible,                              # 100%
        pointed.reduce(0) { |sum,s| sum + s[:score] } # ... or extra credit
      ].max
      unpointed_score = unpointed.reduce(0) { |sum,s| sum + s[:score] }
      max_score = best_pointed_score + unpointed_score
      max_score.to_f / points_possible
    else
      grades.last
    end
  end

  # determines the best +keep+ assignments from submissions for the given q
  # (suitable for use with drop_lowest)
  def big_f_best(q, submissions, cant_drop, keep)
    big_f(q, submissions, cant_drop, keep) { |(a,_),(b,_)| b <=> a }
  end

  # determines the worst +keep+ assignments from submissions for the given q
  # (suitable for use with drop_highest)
  def big_f_worst(q, submissions, cant_drop, keep)
    big_f(q, submissions, cant_drop, keep) { |(a,_),(b,_)| a <=> b }
  end

  # returns grade information from all the assignment groups
  def calculate_total_from_group_scores(group_sums)
    if @course.group_weighting_scheme == 'percent'
      relevant_group_sums = group_sums.reject { |gs|
        gs[:possible].zero? || gs[:possible].nil?
      }
      final_grade = relevant_group_sums.reduce(0) { |grade,gs|
        grade + (gs[:score].to_f / gs[:possible]) * gs[:weight]
      }

      # scale the grade up if total weights don't add up to 100%
      full_weight = relevant_group_sums.reduce(0) { |w,gs| w + gs[:weight] }
      if full_weight.zero?
        final_grade = nil
      elsif full_weight < 100
        final_grade *= 100.0 / full_weight
      end

      {:grade => final_grade.try(:round, 2)}
    else
      total, possible = group_sums.reduce([0,0]) { |(m,n),gs|
        [m + gs[:score], n + gs[:possible]]
      }
      if possible > 0
        final_grade = (total.to_f / possible) * 100
        {
          :grade => final_grade.round(2),
          :total => total.to_f,
          :possible => possible,
        }
      else
        {:grade => nil, :total => total.to_f}
      end
    end
  end

  # this takes a wrapped submission (like from create_group_sums)
  def loggable_submission(wrapped_submission)
    {
      assignment_id: wrapped_submission[:assignment].id,
      score: wrapped_submission[:score],
      total: wrapped_submission[:total],
    }
  end
end