E1929. Visualizations for Instructors

app/assets/javascripts/rubric_stats.js

@@ -0,0 +1,135 @@
+
+function buildSelectArray(prefix, length) {
+    var selected = [];
+    for (i = 0; i < length; i++) {
+        var eID = prefix+"_"+i+"_selector";
+        var selector = document.getElementById(eID);
+        selected.push(selector.checked);
+    }
+    return selected;
+}
+
+var selected_round = 0;
+function toggleRound(control) {
+    selected_round = control.selectedIndex;
+    for (var round = 0; round < round_names.length; round++) {
+        var roundDiv = document.getElementById("round_"+round+"_criteria");
+        var display = null;
+        if (round != selected_round) display = "none";
+        roundDiv.style.display = display;
+    }
+    drawChart();
+}
+
+var selected_assignment_round = 0;
+function toggleAssignmentRound(control) {
+    selected_assignment_round = control.selectedIndex;
+    renderCompareUI();
+}
+
+function renderCompareUI() {
+    for (var assignment = 0; assignment < assignment_names_to_compare.length; assignment++) {
+        for (var round = 0; round < round_names.length; round++) {
+            eID = "assignment_"+assignment+"_round_"+round+"_criteria";
+            var roundDiv = document.getElementById(eID);
+            var display = null;
+            if (assignment != selected_assignment || round != selected_assignment_round) display = "none";
+            roundDiv.style.display = display;
+        }
+    }
+    drawChart();
+}
+
+function toggleMetric(control) {
+    var data = [avg_data, med_data];
+    source_data = data[control.selectedIndex];
+    drawChart();
+}
+
+function toggleAssignment(control) {
+    selected_assignment = control.selectedIndex;
+    renderCompareUI();
+}
+
+// Callback that creates and populates a data table,
+// instantiates the column chart, passes in the data and
+// draws it.
+function drawSingleChart() {
+    var selected_criteria = buildSelectArray("round_"+selected_round+"_criterion", criteria_names[selected_round].length);
+
+    // Create the data table.
+    var data = new google.visualization.DataTable();
+    data.addColumn('string', 'Criteria');
+    data.addColumn('number', round_names[selected_round]);
+    var rows = [];
+    for (criterion = 0; criterion < selected_criteria.length; criterion++) {
+        if (!selected_criteria[criterion]) {
+            continue;
+        }
+        var row = [criteria_names[selected_round][criterion]];
+        row.push(source_data[selected_round][criterion]);
+        rows.push(row);
+    }
+    data.addRows(rows);
+    // Set chart options
+    var options = {
+        'title':'Class Performance By Criterion',
+        'width':700,
+        'height':250
+    };
+    // Instantiate and draw our chart, passing in some options.
+    var chart = new google.visualization.ColumnChart(document.getElementById('chart_div'));
+    chart.draw(data, options);
+}
+
+// Callback that creates and populates a data table,
+// instantiates the column chart, passes in the data and
+// draws it.
+function drawCompareChart() {
+    source_data = avg_data;
+    var prefix = "assignment_"+selected_assignment+"_round_"+selected_assignment_round+"_criterion";
+    var selected_criteria = buildSelectArray(prefix, criteria_names[selected_assignment_round].length);
+
+    // Create the data table.
+    var data = new google.visualization.DataTable();
+    data.addColumn('string', 'Criteria');
+    data.addColumn('number', assignment_name);
+    data.addColumn('number', assignment_names_to_compare[selected_assignment]);
+    var rows = [];
+    for (criterion = 0; criterion < selected_criteria.length; criterion++) {
+        if (!selected_criteria[criterion]) {
+            continue;
+        }
+        var row = [criteria_names[selected_assignment_round][criterion]];
+        row.push(avg_data[selected_assignment_round][criterion]);
+        row.push(avg_data_to_compare[selected_assignment][selected_assignment_round][criterion]);
+        rows.push(row);
+    }
+    data.addRows(rows);
+    // Set chart options
+    var options = {
+        'title':'Class Performance By Criterion For ' + round_names[selected_assignment_round],
+        'width':700,
+        'height':250
+    };
+    // Instantiate and draw our chart, passing in some options.
+    var chart = new google.visualization.ColumnChart(document.getElementById('chart_div'));
+    chart.draw(data, options);
+}
+
+var drawChart = drawSingleChart;
+
+var tabCount = 2;
+function switchToTab(newTab) {
+    var chartFuncs = [drawSingleChart, drawCompareChart];
+    for (tab = 0; tab < tabCount; tab++) {
+        var display = null;
+        if (tab != newTab) display = "none";
+        var selector = document.getElementById("tab_"+tab+"_selector").style;
+        selector.display = display;
+        var tabDiv = document.getElementById("tab_"+tab).style;
+        tabDiv.display = display;
+    }
+    drawChart = chartFuncs[newTab];
+    drawChart();
+}

app/controllers/grades_controller.rb

@@ -6,6 +6,7 @@ class GradesController < ApplicationController
   include StudentTaskHelper
   include AssignmentHelper
   include GradesHelper
+  include AssignmentStatsHelper
 
   def action_allowed?
     case params[:action]
@@ -50,12 +51,28 @@ def view
     end
 
     @scores = @assignment.scores(@questions)
-    averages = calculate_average_vector(@assignment.scores(@questions))
+    averages = calculate_average_vector(@scores)
     @average_chart = bar_chart(averages, 300, 100, 5)
     @avg_of_avg = mean(averages)
     calculate_all_penalties(@assignment.id)
 
     @show_reputation = false
+
+    # Define instance variables for rubric visualization
+    stats = AssignmentStats.new(@assignment.id)
+
+    @avg_data = mean_data(stats)
+    @med_data = median_data(stats)
+    @metric_names = %w[Mean Median]
+
+    @assignment_name = @assignment.name
+    @round_names = round_names(stats)
+    @criteria_names = criteria_names(stats)
+
+    comparable_assignment_stats = @assignment.comparable_assignment_ids.map {|id| AssignmentStats.new(id) }
+
+    @assignment_avg_data = comparison_mean_data(comparable_assignment_stats)
+    @assignment_names = comparison_assignment_names(comparable_assignment_stats)
   end
 
   def view_my_scores

app/helpers/assignment_stats_helper.rb

@@ -0,0 +1,33 @@
+module AssignmentStatsHelper
+  def mean_data(assignment_stats)
+    assignment_stats.rounds.map(&:means)
+  end
+
+  def median_data(assignment_stats)
+    assignment_stats.rounds.map(&:medians)
+  end
+
+  def criteria_names(assignment_stats)
+    rounds = []
+    assignment_stats.rounds.each do |r|
+      rounds << (1..r.number_of_criteria).map {|c| "Criterion #{c}" }
+    end
+    rounds
+  end
+
+  def round_names(assignment_stats)
+    (1..assignment_stats.number_of_rounds).map {|r| "Round #{r}" }
+  end
+
+  def comparison_mean_data(assignment_stats_array)
+    data = []
+    assignment_stats_array.each do |as|
+      data << as.rounds.map(&:means)
+    end
+    data
+  end
+
+  def comparison_assignment_names(assignment_stats_array)
+    assignment_stats_array.map(&:name)
+  end
+end

app/models/assignment.rb

@@ -419,6 +419,26 @@ def review_questionnaire_id(round = nil)
     review_questionnaire_id
   end
 
+  # Provides an array of all comparable assignments. Those are assignments that are part of the same course
+  # and have assignment questionnaires with matching rounds and questionnaire IDs.
+  def comparable_assignment_ids
+    comparable_assignments = Assignment.where(course_id: self.course_id).reject {|a| a.id == self.id }
+    comparable_assignment_ids = comparable_assignments.map(&:id)
+    # Maps round identifiers to questionnaire IDs in this assignment
+    round_questionnaire_hash = {}
+    aqs_with_round = AssignmentQuestionnaire.where(assignment_id: self.id).reject {|q| q.used_in_round.nil? }
+    aqs_with_round.each {|aq| round_questionnaire_hash[aq.used_in_round] = aq.questionnaire_id }
+
+    # Find all assignments with the same questionnaires used in the same rounds and get the intersection
+    # with assignments in the same course retrieved above.
+    round_questionnaire_hash.each do |round, questionnaire|
+      matching_aqs = AssignmentQuestionnaire.where(used_in_round: round, questionnaire_id: questionnaire)
+      assignment_ids = matching_aqs.map(&:assignment_id)
+      comparable_assignment_ids &= assignment_ids
+    end
+    comparable_assignment_ids
+  end
+
   def self.export_details(csv, parent_id, detail_options)
     return csv unless detail_options.value?('true')
     @assignment = Assignment.find(parent_id)

app/models/assignment_questionnaire.rb

@@ -6,4 +6,7 @@ class AssignmentQuestionnaire < ActiveRecord::Base
   scope :retrieve_questionnaire_for_assignment, lambda {|assignment_id|
     joins(:questionnaire).where('assignment_questionnaires.assignment_id = ?', assignment_id)
   }
+  def question_ids_in_order
+    self.questionnaire.question_ids_in_order
+  end
 end

app/models/assignment_stats.rb

@@ -0,0 +1,56 @@
+class AssignmentStats
+  attr_accessor :rounds, :name
+
+  def initialize(assignment_id)
+    @name = Assignment.find(assignment_id).name
+    # These represent rounds
+    aqs_with_round = AssignmentQuestionnaire.where(assignment_id: assignment_id).reject {|q| q.used_in_round.nil? }
+    aqs_with_round.sort_by!(&:used_in_round)
+    # This hash maps question IDs to their zero-indexed positions within their questionnaire
+    question_id_index_hash = {}
+    aqs_with_round.each do |q|
+      q.question_ids_in_order.each_with_index {|value, index| question_id_index_hash[value] = index }
+    end
+    # question_id_index_hash
+    # This hash maps rounds to criteria to scores, max_scores and min_scores
+    scores_hash = {}
+    review_response_maps = ReviewResponseMap.where(reviewed_object_id: assignment_id)
+    review_response_maps.each do |review_response_map|
+      submitted_responses = review_response_map.response.reject {|r| !r.is_submitted }
+      submitted_responses.each do |response|
+        criteria_hash = scores_hash[response.round]
+        if criteria_hash.nil?
+          criteria_hash = {}
+          scores_hash[response.round] = criteria_hash
+        end
+        answers = response.scores.reject {|s| s.answer.nil? }
+        answers.each do |answer|
+          criterion_hash = criteria_hash[answer.question_id]
+          if criterion_hash.nil?
+            criterion_hash = {}
+            criteria_hash[answer.question_id] = criterion_hash
+          end
+          c_scores = criterion_hash[:scores]
+          if c_scores.nil?
+            c_scores = []
+            criterion_hash[:scores] = c_scores
+          end
+          c_scores << answer.answer
+          next unless criterion_hash[:max_score].nil?
+          question = Question.find(answer.question_id)
+          criterion_hash[:question_id] = answer.question_id
+          criterion_hash[:max_score] = question.max_score
+          criterion_hash[:min_score] = question.min_score
+        end
+      end
+    end
+    @rounds = []
+    scores_hash.each_value do |criteria_hash|
+      @rounds << ReviewRoundStats.new(criteria_hash, question_id_index_hash)
+    end
+  end
+
+  def number_of_rounds
+    @rounds.length
+  end
+end

app/models/criterion_stats.rb

@@ -0,0 +1,14 @@
+class CriterionStats
+  attr_accessor :mean, :median
+
+  def initialize(criterion_hash)
+    criterion_hash[:scores].sort!
+    s = criterion_hash[:scores]
+    @median = (s[s.length / 2].to_f + s[(s.length - 1) / 2].to_f) / 2.0
+    mean = s.inject(&:+).to_f / s.length # {|sum, el| sum + el }.to_f / s.length
+    max = criterion_hash[:max_score]
+    min = criterion_hash[:min_score]
+    normalized_mean = (mean - min.to_f) / (max.to_f - min.to_f)
+    @mean = normalized_mean * 100
+  end
+end

app/models/question.rb

@@ -52,6 +52,14 @@ def get_formatted_question_type
     end
   end
 
+  def max_score
+    self.questionnaire.max_question_score
+  end
+
+  def min_score
+    self.questionnaire.min_question_score
+  end
+
   # Placeholder methods, override in derived classes if required.
   # this method decide what to display if an instructor (etc.) is creating or editing a questionnaire
   def edit

app/models/questionnaire.rb

@@ -86,4 +86,9 @@ def validate_questionnaire
     results = Questionnaire.where("id <> ? and name = ? and instructor_id = ?", id, name, instructor_id)
     errors.add(:name, "Questionnaire names must be unique.") if results.present?
   end
+
+  def question_ids_in_order
+    sorted_questions = self.questions.to_a.sort_by!(&:seq)
+    sorted_questions.map(&:id)
+  end
 end

app/models/review_round_stats.rb

@@ -0,0 +1,22 @@
+class ReviewRoundStats
+  attr_accessor :criteria
+
+  def initialize(criteria_hash, question_id_index_hash)
+    @criteria = []
+    criteria_hash.each do |question, criterion_hash|
+      @criteria[question_id_index_hash[question]] = CriterionStats.new(criterion_hash) unless question.nil? || question_id_index_hash[question].nil?
+    end
+  end
+
+  def means
+    @criteria.map(&:mean)
+  end
+
+  def medians
+    @criteria.map(&:median)
+  end
+
+  def number_of_criteria
+    @criteria.length
+  end
+end

app/models/score_view.rb

@@ -1,5 +1,5 @@
 class ScoreView < ActiveRecord::Base
   def readonly?
-    true
+    false
   end
 end