Interpolate between two scenarios

Closes #1684

Author: aaccensi

app/controllers/api/v3/scenarios_controller.rb

@@ -210,7 +210,7 @@ def create
       # POST /api/v3/scenarios/interpolate
       def interpolate
         @interpolated = Scenario::YearInterpolator.call(
-          @scenario, params.require(:end_year).to_i, current_user
+          @scenario, params.require(:end_year).to_i, start_scenario, current_user
         )
 
         Scenario.transaction do
@@ -219,10 +219,9 @@ def interpolate
 
         render json: ScenarioSerializer.new(self, @interpolated)
       rescue ActionController::ParameterMissing
-        render(
-          status: :bad_request,
-          json: { errors: ['Interpolated scenario must have an end year'] }
-        )
+        render json: { errors: ['Interpolated scenario must have an end year'] }, status: :bad_request
+      rescue Scenario::YearInterpolator::InterpolationError => e
+        render json: { errors: [e.message] }, status: :unprocessable_entity
       end
 
       # PUT-PATCH /api/v3/scenarios/:id
@@ -407,17 +406,22 @@ def export
       end
 
       private
+      
+      # Internal: Finds the start scenario for interpolation, if any.
+      #
+      # Returns a Scenario, nil, or raises InterpolationError.
+      def start_scenario
+        return unless params[:start_scenario_id]
 
-      def find_preset_or_scenario
-        @scenario =
-          Preset.get(params[:id]).try(:to_scenario) ||
-          Scenario.find_for_calculation(params[:id])
+        scenario = Scenario.find_by(id: params[:start_scenario_id])
 
-        render_not_found(errors: ['Scenario not found']) unless @scenario
-      end
+        raise Scenario::YearInterpolator::InterpolationError,
+          'Start scenario not found' unless scenario
+
+        raise Scenario::YearInterpolator::InterpolationError, 
+          'Start scenario not accessible' unless can?(:read, scenario)
 
-      def find_scenario
-        @scenario = Scenario.find_for_calculation(params[:id])
+        scenario
       end
 
       # Internal: All the request parameters, filtered.

app/models/scenario/year_interpolator.rb

@@ -4,13 +4,14 @@
 # values will be adjusted to linearly interpolate new values based on the year.
 class Scenario::YearInterpolator
 
-  def self.call(scenario, year, current_user = nil)
-    new(scenario, year, current_user).run
+  def self.call(scenario, year, start_scenario = nil, current_user = nil)
+    new(scenario, year, start_scenario, current_user).run
   end
 
-  def initialize(scenario, year, current_user)
+  def initialize(scenario, year, start_scenario, current_user)
     @scenario = scenario
     @year = year
+    @start_scenario = start_scenario
     @current_user = current_user
   end
 
@@ -29,11 +30,8 @@ def run
     clone.private = @scenario.clone_should_be_private?(@current_user)
 
     if @year != @scenario.end_year
-      clone.user_values =
-        interpolate_input_collection(@scenario.user_values)
-
-      clone.balanced_values =
-        interpolate_input_collection(@scenario.balanced_values)
+      clone.user_values = interpolate_input_collection(:user_values)
+      clone.balanced_values = interpolate_input_collection(:balanced_values)
     end
 
     clone
@@ -61,6 +59,39 @@ def validate!
     if @scenario.scaler
       raise InterpolationError, 'Cannot interpolate scaled scenarios'
     end
+
+    validate_start_scenario! if @start_scenario
+  end
+
+  def validate_start_scenario!
+    if @start_scenario.id == @scenario.id
+      raise InterpolationError,
+        'Start scenario must not be the same as the original scenario'
+    end
+
+    if @start_scenario.end_year > @scenario.end_year
+      raise InterpolationError,
+        'Start scenario must have an end year equal or prior to the ' \
+        "original scenario (#{@scenario.start_year})"
+    end
+
+    if @year < @start_scenario.end_year
+      raise InterpolationError,
+        'Interpolated scenario must have an end year equal or posterior to ' \
+        "the start scenario (#{@start_scenario.end_year})"
+    end
+
+    if @start_scenario.start_year != @scenario.start_year
+      raise InterpolationError,
+        'Start scenario must have the same start year as the original ' \
+        "scenario (#{@scenario.start_year})"
+    end
+
+    if @start_scenario.area_code != @scenario.area_code
+      raise InterpolationError,
+        'Start scenario must have the same area code as the original ' \
+        "scenario (#{@scenario.area_code})"
+    end
   end
 
   # Internal: Receives a collection of inputs and interpolates the values to
@@ -71,13 +102,17 @@ def validate!
   # based in 2030, the input value will be 50.
   #
   # Returns the interpolated inputs.
-  def interpolate_input_collection(collection)
-    num_years = @scenario.end_year - @year
-    total_years = @scenario.end_year - @scenario.start_year
+  def interpolate_input_collection(collection_attribute)
+    start_collection = @start_scenario&.public_send(collection_attribute)
+    collection = @scenario.public_send(collection_attribute)
+    start_year = @start_scenario&.end_year || @scenario.start_year
+    total_years = @scenario.end_year - start_year
+    elapsed_years = @year - start_year
 
     collection.each_with_object(collection.class.new) do |(key, value), interp|
       if (input = Input.get(key))
-        interp[key] = interpolate_input(input, value, total_years, num_years)
+        start = start_collection&.[](key) || input.start_value_for(@scenario)
+        interp[key] = interpolate_input(input, start, value, total_years, elapsed_years)
       end
     end
   end
@@ -86,13 +121,12 @@ def interpolate_input_collection(collection)
   # value in the original scenario.
   #
   # Returns a Numeric or String value for the new user values.
-  def interpolate_input(input, value, total_years, num_years)
+  def interpolate_input(input, start, value, total_years, elapsed_years)
     return value if input.enum? || input.unit == 'bool'
 
-    start = input.start_value_for(@scenario)
     change_per_year = (value - start) / total_years
 
-    start + (change_per_year * (total_years - num_years))
+    start + (change_per_year * elapsed_years)
   end
 
   class InterpolationError < RuntimeError; end

spec/models/scenario/year_interpolator_spec.rb

@@ -209,4 +209,38 @@
       expect(interpolated.heat_network_orders.first.order).to eq(techs)
     end
   end
+
+  context 'when passing a start scenario' do
+    let(:source) do
+      FactoryBot.create(:scenario, {
+        id:          99999, # Avoid a collision with a preset ID
+        end_year:    2050,
+        user_values: { 'grouped_input_one' => 75.0 }
+      })
+    end
+
+    let(:start_scenario) do
+      FactoryBot.create(:scenario, {
+        id:          88888, # Avoid a collision with a preset ID
+        end_year:    2030,
+        user_values: { 'grouped_input_one' => 50.0 }
+      })
+    end
+
+    let(:interpolated) { described_class.call(source, 2040, start_scenario) }
+
+    it 'interpolates based on the start scenario values' do
+      # 50 -> 75 in 20 years
+      # = 62.5 in 10 years
+      expect(interpolated.user_values['grouped_input_one'])
+        .to be_within(1e-2).of(62.5)
+    end
+
+    it 'fails if the start scenario end year > source scenario end year' do
+      # 50 -> 75 in 20 years
+      # = 62.5 in 10 years
+      expect(interpolated.user_values['grouped_input_one'])
+        .to be_within(1e-2).of(62.5)
+    end
+  end
 end

spec/requests/api/v3/interpolate_scenario_spec.rb

@@ -173,4 +173,168 @@
       expect(response).to be_not_found
     end
   end
+
+  context 'with a valid start scenario id' do
+    let(:send_data) do
+      post "/api/v3/scenarios/#{source.id}/interpolate",
+        params: { end_year: 2040, start_scenario_id: start_scenario.id },
+        headers: access_token_header(user, :write)
+    end
+
+    let(:start_scenario) { create(:scenario, end_year: 2030, user: user) }
+
+    before do
+      source
+      start_scenario
+    end
+
+    it 'returns 200 OK' do
+      send_data
+      expect(response.status).to eq(200)
+    end
+
+    it 'saves the scenario' do
+      expect { send_data }.to change(Scenario, :count).by(1)
+    end
+
+    it 'sends the scenario ID' do
+      expect(response_data).to include('id' => Scenario.last.id)
+    end
+
+    it 'sets the area code' do
+      expect(response_data).to include('area_code' => source.area_code)
+    end
+
+    it 'sets the end year' do
+      expect(response_data).to include('end_year' => 2040)
+    end
+  end
+
+  context 'with an inexistent start scenario id' do
+    let(:send_data) do
+      post "/api/v3/scenarios/#{source.id}/interpolate",
+        params: { end_year: 2040, start_scenario_id: 999999 },
+        headers: token_header
+    end
+
+    before { source }
+
+    it 'returns 422 Unprocessable Entity' do
+      send_data
+      expect(response.status).to be(422)
+    end
+
+    it 'sends back an error message' do
+      expect(response_data).to include('errors' => ["Start scenario not found"])
+    end
+  end
+
+  context 'with an inaccessible start scenario' do
+    let(:send_data) do
+      post "/api/v3/scenarios/#{source.id}/interpolate",
+        params: { end_year: 2040, start_scenario_id: start_scenario.id },
+        headers: token_header
+    end
+
+    let(:start_scenario) { create(:scenario, end_year: 2030, user: other_user, private: true) }
+    let(:other_user) { create(:user) }
+
+    before { source }
+
+    it 'returns 422 Unprocessable Entity' do
+      send_data
+      expect(response.status).to be(422)
+    end
+
+    it 'sends back an error message' do
+      expect(response_data).to include('errors' => ["Start scenario not accessible"])
+    end
+  end
+
+  context 'with same start scenario as source scenario' do
+    let(:send_data) do
+      post "/api/v3/scenarios/#{source.id}/interpolate",
+        params: { end_year: 2040, start_scenario_id: source.id },
+        headers: token_header
+    end
+
+    before { source }
+
+    it 'returns 422 Unprocessable Entity' do
+      send_data
+      expect(response.status).to be(422)
+    end
+
+    it 'sends back an error message' do
+      expect(response_data).to include(
+        'errors' => ['Start scenario must not be the same as the original scenario'])
+    end
+  end
+
+  context 'with an invalid interpolation year (earlier than start scenario)' do
+    let(:send_data) do
+      post "/api/v3/scenarios/#{source.id}/interpolate",
+        params: { end_year: 2040, start_scenario_id: start_scenario.id },
+        headers: token_header
+    end
+
+    let(:start_scenario) { create(:scenario, end_year: 2055, user: user) }
+
+    before { source }
+
+    it 'returns 422 Unprocessable Entity' do
+      send_data
+      expect(response.status).to be(422)
+    end
+
+    it 'sends back an error message' do
+      expect(response_data).to include('errors' => ['Start scenario must have an end ' \
+        "year equal or prior to the original scenario (#{source.start_year})"])
+    end
+  end
+
+  context 'with an invalid interpolation year (earlier than start scenario)' do
+    let(:send_data) do
+      post "/api/v3/scenarios/#{source.id}/interpolate",
+        params: { end_year: 2040, start_scenario_id: start_scenario.id },
+        headers: token_header
+    end
+
+    let(:start_scenario) { create(:scenario, end_year: 2045, user: user) }
+
+    before { source }
+
+    it 'returns 422 Unprocessable Entity' do
+      send_data
+      expect(response.status).to be(422)
+    end
+
+    it 'sends back an error message' do
+      expect(response_data).to include('errors' => ['Interpolated scenario must have an ' \
+        "end year equal or posterior to the start scenario (#{start_scenario.end_year})"])
+    end
+  end
+
+  context 'with an invalid start scenario area code' do
+    let(:send_data) do
+      post "/api/v3/scenarios/#{source.id}/interpolate",
+        params: { end_year: 2040, start_scenario_id: start_scenario.id },
+        headers: token_header
+    end
+
+    let(:start_scenario) { create(:scenario, end_year: 2030, user: user, area_code: 'de') }
+
+    before { source }
+
+    it 'returns 422 Unprocessable Entity' do
+      send_data
+      expect(response.status).to be(422)
+    end
+
+    it 'sends back an error message' do
+      expect(response_data).to include('errors' => ['Start scenario must have the same ' \
+        "area code as the original scenario (#{source.area_code})"])
+    end
+  end
+
 end