Ultima ug200 staging

app/controllers/batches_controller.rb

@@ -387,24 +387,34 @@ def find_batch_by_barcode
   # the batch. Ultima sample sheets are allowed to be downloaded without
   # authentication. For all other pipelines, the user must be logged in.
   #
+  # @note When checking the pipeline class, always check the most specific
+  #   subclass first in the inheritance hierarchy, before considering parent
+  #   classes.
+  #
   # @return [Boolean] true if download is allowed, false otherwise
   def allow_sample_sheet_download?
-    @batch.pipeline.is_a?(UltimaSequencingPipeline) || logged_in?
+    return true if @batch.pipeline.is_a?(UltimaUG200SequencingPipeline)
+    return true if @batch.pipeline.is_a?(UltimaSequencingPipeline)
+
+    logged_in?
   end
 
   # Generates and sends the appropriate sample sheet(s) for the batch.
+  #
+  # @note When checking the pipeline class, always check the most specific
+  #   subclass first in the inheritance hierarchy, before considering parent
+  #   classes.
+  #
   # @return [void]
   def generate_sample_sheet
     return redirect_to(login_path) unless allow_sample_sheet_download?
 
-    if @batch.pipeline.is_a?(ElementAvitiSequencingPipeline)
-      generate_element_aviti_sample_sheet
-    elsif @batch.pipeline.is_a?(UltimaSequencingPipeline)
-      generate_ultima_sample_sheet
-    else
-      flash[:error] = 'Sample sheet generation is not supported for this pipeline.'
-      redirect_to controller: 'batches', action: 'show', id: @batch.id
-    end
+    return generate_element_aviti_sample_sheet if @batch.pipeline.is_a?(ElementAvitiSequencingPipeline)
+    return generate_ultima_ug200_sample_sheet if @batch.pipeline.is_a?(UltimaUG200SequencingPipeline)
+    return generate_ultima_sample_sheet if @batch.pipeline.is_a?(UltimaSequencingPipeline)
+
+    flash[:error] = 'Sample sheet generation is not supported for this pipeline.'
+    redirect_to controller: 'batches', action: 'show', id: @batch.id
   end
 
   private
@@ -422,7 +432,21 @@ def generate_element_aviti_sample_sheet
   # Generates and sends the Ultima sample sheet ZIP archive for the batch.
   # @return [void]
   def generate_ultima_sample_sheet
-    zip_string = UltimaSampleSheet::SampleSheetGenerator.generate(@batch)
+    send_run_manifest_zip(UltimaSampleSheet::SampleSheetGenerator)
+  end
+
+  # Generates and sends the Ultima UG200 sample sheet ZIP archive for the batch.
+  # @return [void]
+  def generate_ultima_ug200_sample_sheet
+    send_run_manifest_zip(UltimaSampleSheet::UG200SampleSheetGenerator)
+  end
+
+  # Helper method to generate and send the Ultima sample sheet ZIP archive for
+  # the batch using the provided generator class.
+  # @param generator [Class] the sample sheet generator class to use
+  # @return [void]
+  def send_run_manifest_zip(generator)
+    zip_string = generator.generate(@batch)
     send_data zip_string,
               type: 'application/zip',
               filename: "batch_#{@batch.id}_run_manifest.zip",

app/controllers/ultima_sample_sheet/sample_sheet_generator.rb

@@ -15,33 +15,48 @@ def self.generate(batch)
   # for each request in the given Ultima sequencing batch.
   class Generator # rubocop:disable Metrics/ClassLength
     PLATE_LENGTH = 8 # Assumes 96-well tag plates with 8 rows (A-H).
-    HEADER_TITLE = ['[Header]'].freeze
-    GLOBAL_TITLE = ['[Global]'].freeze
-    GLOBAL_HEADERS = %w[
-      Application
-      sequencing_recipe
-      analysis_recipe
-    ].freeze
-    SAMPLES_TITLE = ['[Samples]'].freeze
-    SAMPLES_HEADERS = %w[
-      Sample_ID
-      Library_name
-      Index_Barcode_Num
-      Index_Barcode_Sequence
-      Barcode_Plate_Num
-      Barcode_Plate_Well
-      application_type
-      study_id
-    ].freeze
-    NUM_COLUMS = SAMPLES_HEADERS.size
-    # The names of the Ultima tag groups are mapped to the index numbers for
-    # the Barcode_Plate_Num column, i.e. 1 or 2. The number is also used for
-    # determining the consistent starting index number for the
-    # Index_Barcode_Num column, i.e. Z0001 or Z097.
-    ULTIMA_TAG_GROUPS = {
-      'Ultima P1' => 1,
-      'Ultima P2' => 2
-    }.freeze
+
+    # Using config methods instead of constants to allow easier overriding.
+    def header_title_config
+      ['[Header]'].freeze
+    end
+
+    def global_title_config
+      ['[Global]'].freeze
+    end
+
+    def global_headers_config
+      %w[Application sequencing_recipe analysis_recipe].freeze
+    end
+
+    def samples_title_config
+      ['[Samples]'].freeze
+    end
+
+    def samples_headers_config
+      %w[
+        Sample_ID Library_name Index_Barcode_Num Index_Barcode_Sequence
+        Barcode_Plate_Num Barcode_Plate_Well application_type study_id
+      ].freeze
+    end
+
+    def num_columns_config
+      samples_headers_config.size
+    end
+
+    # Tag group config used to derive CSV plate numbers and Z-index starts.
+    # Values are explicit to avoid arithmetic assumptions in index mapping.
+    def ultima_tag_groups_config
+      {
+        'Ultima P1' => { plate_num: 1, z_start: 1 },
+        'Ultima P2' => { plate_num: 2, z_start: 97 },
+        'Ultima P3' => { plate_num: 3, z_start: 193 },
+        'UG-RD-1916 (Solaris 2.0 V1 PCR-Free Adapters for Ultima Genomics P4)' => {
+          plate_num: 4,
+          z_start: 289
+        }
+      }.freeze
+    end
 
     # Initializes the generator with the given batch.
     # @param batch [UltimaSequencingBatch] the batch to generate sample sheets for
@@ -96,7 +111,7 @@ def folder_name
     # @param csv [CSV] the CSV object to append rows to
     # @param request [UltimaSequencingRequest] the request whose header data is to be added
     def add_header_section(csv, request)
-      csv << pad(HEADER_TITLE)
+      csv << pad(header_title_config)
       free_form_text = "Batch #{@batch.id} #{request.asset.human_barcode}"
       csv << pad([free_form_text])
     end
@@ -106,8 +121,8 @@ def add_header_section(csv, request)
     # @param csv [CSV] the CSV object to append rows to
     # @param _request [UltimaSequencingRequest] the request whose global data is to be added
     def add_global_section(csv, _request)
-      csv << pad(GLOBAL_TITLE)
-      csv << pad(GLOBAL_HEADERS)
+      csv << pad(global_title_config)
+      csv << pad(global_headers_config)
       # Currently there is only one UltimaGlobal record; get the last one.
       # Future enhancements may allow selecting different records based on
       # sequencing request or batch properties.
@@ -121,22 +136,29 @@ def add_global_section(csv, _request)
     # @param csv [CSV] the CSV object to append rows to
     # @param request [UltimaSequencingRequest] the request whose samples are to be added
     def add_samples_section(csv, request)
-      csv << pad(SAMPLES_TITLE)
-      csv << pad(SAMPLES_HEADERS)
+      csv << pad(samples_title_config)
+      csv << pad(samples_headers_config)
       request.asset.aliquots.sort_by(&:id).each do |aliquot|
-        csv << [
-          sample_id_for(aliquot),
-          library_name_for(aliquot),
-          index_barcode_num_for(aliquot),
-          index_barcode_sequence_for(aliquot),
-          barcode_plate_num_for(aliquot),
-          barcode_plate_well_for(aliquot),
-          'native', # application_type
-          study_id_for(aliquot)
-        ]
+        csv << sample_row_for(aliquot)
       end
     end
 
+    # Builds a sample section row for a single aliquot.
+    # @param aliquot [Aliquot] the aliquot whose sample row is needed
+    # @return [Array<String>] the sample row values
+    def sample_row_for(aliquot)
+      [
+        sample_id_for(aliquot),
+        library_name_for(aliquot),
+        index_barcode_num_for(aliquot),
+        index_barcode_sequence_for(aliquot),
+        barcode_plate_num_for(aliquot),
+        barcode_plate_well_for(aliquot),
+        'native', # application_type
+        study_id_for(aliquot)
+      ]
+    end
+
     # Returns a unique sample_ID for the given aliquot. This prefixes numbers
     # with 's' (lowercase s character) for Sample_ID column, as in s1 … sN,
     # where N is num of samples on wafer. It starts them with s1 for each wafer,
@@ -196,29 +218,30 @@ def study_id_for(aliquot)
     end
 
     # Returns a mapping of all Ultima tags to their respective 1-based index
-    # numbers. This sorts the tags by their tag group ID and map ID to ensure
-    # consistent ordering. The index numbers run across all Ultima tag groups,
-    # i.e. the index is 1 for the first tag in the first tag group and 97 for
-    # the first tag in the second tag group.
+    # numbers. Each group's starting index is taken directly from
+    # ultima_tag_groups_config[:z_start], so numbering is independent of which
+    # other tag groups exist in the database.
     # @return [Hash{Tag => Integer}] mapping of tags to index numbers
     def tag_index_map
-      @tag_index_map ||= begin
-        tags = ultima_tag_groups.flat_map { |tg| tg.tags.sort_by(&:map_id) }
-        tags.each_with_index.to_h { |tag, i| [tag, i + 1] }
+      @tag_index_map ||= ultima_tag_groups.each_with_object({}) do |tag_group, map|
+        start_index = ultima_tag_groups_config[tag_group.name][:z_start]
+        tag_group.tags.sort_by(&:map_id).each_with_index { |tag, i| map[tag] = start_index + i }
       end
     end
 
     # Returns a mapping of all Ultima tag groups to 1-based index numbers.
-    # This indexes the tag groups as given in the ULTIMA_TAG_GROUPS hash.
+    # This indexes the tag groups as given in the ultima_tag_groups_config hash.
     # @return [Hash{TagGroup => Integer}] mapping of tag groups to index numbers
     def tag_group_index_map
-      @tag_group_index_map ||= ultima_tag_groups.index_with { |tg| ULTIMA_TAG_GROUPS[tg.name] }
+      @tag_group_index_map ||= ultima_tag_groups.index_with { |tg| ultima_tag_groups_config[tg.name][:plate_num] }
     end
 
-    # Returns all unique tag groups used for Ultima sequencing from database.
+    # Returns all unique tag groups used for Ultima sequencing from database,
+    # sorted by their index number as defined in ultima_tag_groups_config.
     # @return [Array<TagGroup>] the tag groups used for Ultima sequencing
     def ultima_tag_groups
-      @ultima_tag_groups ||= TagGroup.where(name: ULTIMA_TAG_GROUPS.keys)
+      @ultima_tag_groups ||= TagGroup.where(name: ultima_tag_groups_config.keys)
+        .sort_by { |tg| ultima_tag_groups_config[tg.name][:plate_num] }
     end
 
     # Returns the requests associated with the batch.
@@ -250,7 +273,7 @@ def sample_id_index_map
     # @param row [Array<String>] the row to pad (defaults to an empty array)
     # @return [Array<String>] the padded row
     def pad(row = [])
-      row + Array.new(NUM_COLUMS - row.size, '')
+      row + Array.new(num_columns_config - row.size, '')
     end
   end
 end

app/controllers/ultima_sample_sheet/ug200_sample_sheet_generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module UltimaSampleSheet::UG200SampleSheetGenerator
+  # Initiates the sample sheet generation for the given batch.
+  # @param batch [Batch] the Ultima UG200 sequencing batch to generate sample sheets for
+  # @return [String] the ZIP archive as a binary string
+  def self.generate(batch)
+    Generator.new(batch).generate
+  end
+
+  # Ultima UG200 sample sheet generator class.
+  # Uses the shared Ultima base implementation with UG200-specific globals and tags.
+  class Generator < UltimaSampleSheet::SampleSheetGenerator::Generator
+    def global_headers_config
+      ['Application'].freeze
+    end
+
+    # Added ultima_tag_groups_config items to the parent class to make them
+    # available to all Ultima sample sheet generators.
+
+    private
+
+    # Adds the global section to the CSV for UG200.
+    # The request parameter is currently unused.
+    # @param csv [CSV] the CSV object to append rows to
+    # @param _request [UltimaSequencingRequest] the request whose global data is to be added
+    def add_global_section(csv, _request)
+      csv << pad(global_title_config)
+      csv << pad(global_headers_config)
+      data = ['WGS Native'] # Application
+      csv << pad(data)
+    end
+  end
+end

app/helpers/submissions_helper.rb

@@ -139,7 +139,8 @@ def submission_link(submission, options)
   def field_selection_tag(request_options, field_info, name_format, enforce_required)
     select_tag(
       name_format % field_info.key,
-      options_for_select(field_info.selection.map(&:to_s), request_options[field_info.key]),
+      options_for_select(field_info.selection.map(&:to_s),
+                         request_options[field_info.key].presence || field_info.default_value),
       class: 'custom-select',
       required: enforce_required && field_info.required,
       read_only: field_info.selection.size == 1

app/models/bulk_submission.rb

@@ -253,7 +253,8 @@ def process # rubocop:todo Metrics/CyclomaticComplexity
     'scrna core cells per chip well',
     '% phix requested',
     'low diversity',
-    'ot recipe'
+    'ot recipe',
+    'wafer size'
   ].freeze
 
   ALIAS_FIELDS = { 'plate barcode' => 'barcode', 'tube barcode' => 'barcode' }.freeze
@@ -360,7 +361,8 @@ def extract_request_options(details)
         ['scrna core cells per chip well', 'cells_per_chip_well'],
         ['% phix requested', 'percent_phix_requested'],
         ['low diversity', 'low_diversity'],
-        ['ot recipe', 'ot_recipe']
+        ['ot recipe', 'ot_recipe'],
+        ['wafer size', 'wafer_size']
       ].each do |source_key, target_key|
         assign_value_if_source_present(details, source_key, request_options, target_key)
       end

app/models/ultima_sequencing_pipeline.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Specialized sequencing pipeline for Ultima
+# Specialized sequencing pipeline for Ultima UG100
 class UltimaSequencingPipeline < SequencingPipeline
   def ot_recipe_consistent_for_batch?(batch)
     ot_recipe_list = batch.requests.filter_map { |request| request.request_metadata.ot_recipe }

app/models/ultima_ug200_sequencing_pipeline.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Specialized sequencing pipeline for Ultima UG200
+class UltimaUG200SequencingPipeline < UltimaSequencingPipeline
+  def wafer_size_consistent_for_batch?(batch)
+    wafer_size_list = batch.requests.filter_map { |request| request.request_metadata.wafer_size }
+
+    # There are some requests that don't have the wafer_size attribute
+    return false if wafer_size_list.size != batch.requests.size
+
+    (wafer_size_list.uniq.size == 1)
+  end
+end

app/models/ultima_ug200_sequencing_request.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Request class specific to the Ultima UG200 sequencing platform.
+# Includes wafer size and OT recipe.
+class UltimaUG200SequencingRequest < SequencingRequest
+  include Api::Messages::UseqWaferIo::LaneExtensions
+
+  FREE = 'Free'
+  FLEX = 'Flex'
+  OT_RECIPE_OPTIONS = [FREE, FLEX].freeze
+
+  has_metadata as: Request do
+    # Defining the sequencing request metadata here again, as 'has_metadata'
+    # does not automatically append these custom attributes to the request.
+    #
+    # The has_metadata call dynamically defines an inner Metadata class and
+    # takes the attributes from the block and adds them to the Metadata class.
+    # There is an assumption that the inner Metadata class is available in a
+    # sequencing request class defintion. Calling has_metadata again does not
+    # inherit the attributes given in the block supplied in the superclass.
+    # They need to be supplied again for this class for a proper inner Metadata
+    # class definition. In a future refactoring these attributes can be moved a
+    # class attribute and subclasses can merge its own attibutes to that. A
+    # common method can set up the inner Metadata class in the subclasses.
+    custom_attribute(:fragment_size_required_from, integer: true, minimum: 1)
+    custom_attribute(:fragment_size_required_to, integer: true, minimum: 1)
+
+    custom_attribute(:ot_recipe, default: FREE, in: OT_RECIPE_OPTIONS, required: true)
+    enum :ot_recipe, { Free: 0, Flex: 1 }
+    custom_attribute(:wafer_size, default: '10TB', validator: true, required: true, selection: true)
+  end
+
+  # Delegate to request_metadata so the attributes are visible to the validator in the RSpec tests.
+  # This delegation has no real effect outside of the tests.
+  delegate :wafer_size, :ot_recipe, to: :request_metadata
+
+  # Generates unique wafer ID, concatenation of batch_for_opentrons,
+  # id_pool_lims, and request_order.
+  # @return [String] unique wafer ID for LIMS
+  def id_wafer_lims
+    "#{batch.id}_#{source_labware.human_barcode}_#{position}"
+  end
+end