spacr 0.3.52__py3-none-any.whl → 0.3.60__py3-none-any.whl

spacr/sequencing.py

@@ -125,7 +125,7 @@ def process_chunk(chunk_data):
                         consensus_sequences.append(consensus_seq)
                         column_sequence = match.group('column')
                         grna_sequence = match.group('grna')
-                        row_sequence = match.group('row')
+                        row_sequence = match.group('row_name')
                         columns.append(column_sequence)
                         grnas.append(grna_sequence)
                         rows.append(row_sequence)
@@ -176,7 +176,7 @@ def process_chunk(chunk_data):
                         consensus_sequences.append(consensus_seq)
                         column_sequence = match.group('column')
                         grna_sequence = match.group('grna')
-                        row_sequence = match.group('row')
+                        row_sequence = match.group('row_name')
                         columns.append(column_sequence)
                         grnas.append(grna_sequence)
                         rows.append(row_sequence)
@@ -532,7 +532,7 @@ def graph_sequencing_stats(settings):
         # Iterate through the fraction thresholds
         for threshold in fraction_thresholds:
             filtered_df = df[df['fraction'] >= threshold]
-            unique_count = filtered_df.groupby(['plate', 'row', 'column'])['grna'].nunique().mean()
+            unique_count = filtered_df.groupby(['plate', 'row_name', 'column'])['grna'].nunique().mean()
             results.append((threshold, unique_count))
 
         results_df = pd.DataFrame(results, columns=['fraction_threshold', 'unique_count'])
@@ -588,17 +588,21 @@ def graph_sequencing_stats(settings):
     # Apply the closest threshold to the DataFrame
     df = df[df['fraction'] >= closest_threshold]
 
-    # Group by 'plate', 'row', 'column' and compute unique counts of 'grna'
-    unique_counts = df.groupby(['plate', 'row', 'column'])['grna'].nunique().reset_index(name='unique_counts')
-    unique_count_mean = df.groupby(['plate', 'row', 'column'])['grna'].nunique().mean()
-    unique_count_std = df.groupby(['plate', 'row', 'column'])['grna'].nunique().std()
+    # Group by 'plate', 'row_name', 'column' and compute unique counts of 'grna'
+    unique_counts = df.groupby(['plate', 'row_name', 'column'])['grna'].nunique().reset_index(name='unique_counts')
+    unique_count_mean = df.groupby(['plate', 'row_name', 'column'])['grna'].nunique().mean()
+    unique_count_std = df.groupby(['plate', 'row_name', 'column'])['grna'].nunique().std()
 
     # Merge the unique counts back into the original DataFrame
-    df = pd.merge(df, unique_counts, on=['plate', 'row', 'column'], how='left')
+    df = pd.merge(df, unique_counts, on=['plate', 'row_name', 'column'], how='left')
 
     print(f"unique_count mean: {unique_count_mean} std: {unique_count_std}")
-    display(df)
     #_plot_density(df, dependent_variable='unique_counts')
+    
+    has_underscore = df['row_name'].str.contains('_').any()
+    if has_underscore:
+        df['row_name'] = df['row_name'].apply(lambda x: x.split('_')[1])
+    
     plot_plates(df=df, variable='unique_counts', grouping='mean', min_max='allq', cmap='viridis',min_count=0, verbose=True, dst=dst)
     
     return closest_threshold

spacr/settings.py

@@ -198,7 +198,7 @@ def set_default_umap_image_settings(settings={}):
     settings.setdefault('smooth_lines', True)
     settings.setdefault('clustering', 'dbscan')
     settings.setdefault('exclude', None)
-    settings.setdefault('col_to_compare', 'col')
+    settings.setdefault('col_to_compare', 'column_name')
     settings.setdefault('pos', 'c1')
     settings.setdefault('neg', 'c2')
     settings.setdefault('embedding_by_controls', False)
@@ -289,7 +289,7 @@ def set_default_analyze_screen(settings):
     settings.setdefault('minimum_cell_count',25)
     settings.setdefault('n_estimators',100)
     settings.setdefault('test_size',0.2)
-    settings.setdefault('location_column','col')
+    settings.setdefault('location_column','column_name')
     settings.setdefault('positive_control','c2')
     settings.setdefault('negative_control','c1')
     settings.setdefault('exclude',None)
@@ -337,8 +337,9 @@ def set_default_train_test_model(settings):
     return settings
 
 def set_generate_training_dataset_defaults(settings):
-
+    
     settings.setdefault('src','path')
+    settings.setdefault('tables',['cell', 'nucleus', 'pathogen', 'cytoplasm'])
     settings.setdefault('dataset_mode','metadata')
     settings.setdefault('annotation_column','test')
     settings.setdefault('annotated_classes',[1,2])
@@ -346,7 +347,7 @@ def set_generate_training_dataset_defaults(settings):
     settings.setdefault('size',224)
     settings.setdefault('test_split',0.1)
     settings.setdefault('class_metadata',[['c1'],['c2']])
-    settings.setdefault('metadata_type_by','col')
+    settings.setdefault('metadata_type_by','column_name')
     settings.setdefault('channel_of_interest',3)
     settings.setdefault('custom_measurement',None)
     settings.setdefault('tables',None)
@@ -369,7 +370,7 @@ def deep_spacr_defaults(settings):
     settings.setdefault('size',224)
     settings.setdefault('test_split',0.1)
     settings.setdefault('class_metadata',[['c1'],['c2']])
-    settings.setdefault('metadata_type_by','col')
+    settings.setdefault('metadata_type_by','column_name')
     settings.setdefault('channel_of_interest',3)
     settings.setdefault('custom_measurement',None)
     settings.setdefault('tables',None)
@@ -453,7 +454,7 @@ def get_analyze_recruitment_default_settings(settings):
     settings.setdefault('pathogen_plate_metadata',[['c1', 'c2', 'c3'],['c4','c5', 'c6']])
     settings.setdefault('treatments',['cm', 'lovastatin'])
     settings.setdefault('treatment_plate_metadata',[['r1', 'r2','r3'], ['r4', 'r5','r6']])
-    settings.setdefault('metadata_types',['col', 'col', 'row'])
+    settings.setdefault('metadata_types',['column_name', 'column_name', 'row_name'])
     settings.setdefault('channel_dims',[0,1,2,3])
     settings.setdefault('cell_chann_dim',3)
     settings.setdefault('cell_mask_dim',4)
@@ -531,18 +532,22 @@ def get_perform_regression_default_settings(settings):
     settings.setdefault('score_data','list of paths')
     settings.setdefault('positive_control','239740')
     settings.setdefault('negative_control','233460')
+    settings.setdefault('min_n',0)
     settings.setdefault('controls',['000000_1','000000_10','000000_11','000000_12','000000_13','000000_14','000000_15','000000_16','000000_17','000000_18','000000_19','000000_20','000000_21','000000_22','000000_23','000000_24','000000_25','000000_26','000000_27','000000_28','000000_29','000000_3','000000_30','000000_31','000000_32','000000_4','000000_5','000000_6','000000_8','000000_9'])
-    settings.setdefault('fraction_threshold',0.12)
+    settings.setdefault('fraction_threshold',None)
     settings.setdefault('dependent_variable','pred')
     settings.setdefault('threshold_method','std')
     settings.setdefault('threshold_multiplier',3)
+    settings.setdefault('target_unique_count',5)
     settings.setdefault('transform',None)
+    settings.setdefault('log_x',False)
+    settings.setdefault('log_y',False)
+    settings.setdefault('x_lim',None)
     settings.setdefault('agg_type','mean')
-    settings.setdefault('min_cell_count',25)
+    settings.setdefault('min_cell_count',None)
     settings.setdefault('regression_type','ols')
     settings.setdefault('random_row_column_effects',False)
     settings.setdefault('split_axis_lims','')
-    settings.setdefault('plate','')
     settings.setdefault('cov_type',None)
     settings.setdefault('alpha',1)
     settings.setdefault('filter_value',['c1', 'c2', 'c3'])
@@ -557,6 +562,7 @@ def get_perform_regression_default_settings(settings):
         print(f"Using alpha as quantile for quantile regression, alpha: {settings['alpha']}")
         settings['agg_type'] = None
         print(f'agg_type set to None for quantile regression')
+        
     return settings
 
 def get_check_cellpose_models_default_settings(settings):

spacr/submodules.py

@@ -341,17 +341,17 @@ def count_phenotypes(settings):
     unique_values_count = df[settings['annotation_column']].nunique(dropna=True)
     print(f"Unique values in {settings['annotation_column']} (excluding NaN): {unique_values_count}")
 
-    # Count unique values in 'value' column, grouped by 'plate', 'row', 'column'
-    grouped_unique_count = df.groupby(['plate', 'row', 'column'])[settings['annotation_column']].nunique(dropna=True).reset_index(name='unique_count')
+    # Count unique values in 'value' column, grouped by 'plate', 'row_name', 'column'
+    grouped_unique_count = df.groupby(['plate', 'row_name', 'column'])[settings['annotation_column']].nunique(dropna=True).reset_index(name='unique_count')
     display(grouped_unique_count)
 
     save_path = os.path.join(settings['src'], 'phenotype_counts.csv')
 
     # Group by plate, row, and column, then count the occurrences of each unique value
-    grouped_counts = df.groupby(['plate', 'row', 'column', 'value']).size().reset_index(name='count')
+    grouped_counts = df.groupby(['plate', 'row_name', 'column', 'value']).size().reset_index(name='count')
 
     # Pivot the DataFrame so that unique values are columns and their counts are in the rows
-    pivot_df = grouped_counts.pivot_table(index=['plate', 'row', 'column'], columns='value', values='count', fill_value=0)
+    pivot_df = grouped_counts.pivot_table(index=['plate', 'row_name', 'column'], columns='value', values='count', fill_value=0)
 
     # Flatten the multi-level columns
     pivot_df.columns = [f"value_{int(col)}" for col in pivot_df.columns]
@@ -376,17 +376,17 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
                             column='column', value='c3', plate=None, save_paths=None):
 
     def calculate_well_score_fractions(df, class_columns='cv_predictions'):
-        if all(col in df.columns for col in ['plate', 'row', 'column']):
-            df['prc'] = df['plate'] + '_' + df['row'] + '_' + df['column']
+        if all(col in df.columns for col in ['plate', 'row_name', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row_name'] + '_' + df['column']
         else:
-            raise ValueError("Cannot find 'plate', 'row', or 'column' in df.columns")
-        prc_summary = df.groupby(['plate', 'row', 'column', 'prc']).size().reset_index(name='total_rows')
-        well_counts = (df.groupby(['plate', 'row', 'column', 'prc', class_columns])
+            raise ValueError("Cannot find 'plate', 'row_name', or 'column' in df.columns")
+        prc_summary = df.groupby(['plate', 'row_name', 'column', 'prc']).size().reset_index(name='total_rows')
+        well_counts = (df.groupby(['plate', 'row_name', 'column', 'prc', class_columns])
                        .size()
                        .unstack(fill_value=0)
                        .reset_index()
                        .rename(columns={0: 'class_0', 1: 'class_1'}))
-        summary_df = pd.merge(prc_summary, well_counts, on=['plate', 'row', 'column', 'prc'], how='left')
+        summary_df = pd.merge(prc_summary, well_counts, on=['plate', 'row_name', 'column', 'prc'], how='left')
         summary_df['class_0_fraction'] = summary_df['class_0'] / summary_df['total_rows']
         summary_df['class_1_fraction'] = summary_df['class_1'] / summary_df['total_rows']
         return summary_df
@@ -481,8 +481,8 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
         return result
 
     def calculate_well_read_fraction(df, count_column='count'):
-        if all(col in df.columns for col in ['plate', 'row', 'column']):
-            df['prc'] = df['plate'] + '_' + df['row'] + '_' + df['column']
+        if all(col in df.columns for col in ['plate', 'row_name', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row_name'] + '_' + df['column']
         else:
             raise ValueError("Cannot find plate, row or column in df.columns")
         grouped_df = df.groupby('prc')[count_column].sum().reset_index()
@@ -501,18 +501,18 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
                 reads_df_temp['plate'] = f"plate{i+1}"
                 scores_df_temp['plate'] = f"plate{i+1}"
                 
-                if 'col' in reads_df_temp.columns:
-                    reads_df_temp = reads_df_temp.rename(columns={'col': 'column'})
                 if 'column_name' in reads_df_temp.columns:
                     reads_df_temp = reads_df_temp.rename(columns={'column_name': 'column'})
-                if 'col' in scores_df_temp.columns:
-                    scores_df_temp = scores_df_temp.rename(columns={'col': 'column'})
+                if 'column_name' in reads_df_temp.columns:
+                    reads_df_temp = reads_df_temp.rename(columns={'column_name': 'column'})
+                if 'column_name' in scores_df_temp.columns:
+                    scores_df_temp = scores_df_temp.rename(columns={'column_name': 'column'})
                 if 'column_name' in scores_df_temp.columns:
                     scores_df_temp = scores_df_temp.rename(columns={'column_name': 'column'})
                 if 'row_name' in reads_df_temp.columns:
-                    reads_df_temp = reads_df_temp.rename(columns={'row_name': 'row'})
+                    reads_df_temp = reads_df_temp.rename(columns={'row_name': 'row_name'})
                 if 'row_name' in scores_df_temp.columns:
-                    scores_df_temp = scores_df_temp.rename(columns={'row_name': 'row'})
+                    scores_df_temp = scores_df_temp.rename(columns={'row_name': 'row_name'})
                     
                 reads_ls.append(reads_df_temp)
                 scores_ls.append(scores_df_temp)
@@ -539,7 +539,7 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
     
     df_emp = pd.DataFrame([(key, val[0], val[1], val[0] / (val[0] + val[1]), val[1] / (val[0] + val[1])) for key, val in empirical_dict.items()],columns=['key', 'value1', 'value2', 'pc_fraction', 'nc_fraction'])
     
-    df = pd.merge(df, df_emp, left_on='row', right_on='key')
+    df = pd.merge(df, df_emp, left_on='row_name', right_on='key')
     
     if any in y_columns not in df.columns:
         print(f"columns in dataframe:")

spacr/timelapse.py

@@ -533,14 +533,14 @@ def exponential_decay(x, a, b, c):
 
 def preprocess_pathogen_data(pathogen_df):
     # Group by identifiers and count the number of parasites
-    parasite_counts = pathogen_df.groupby(['plate', 'row', 'col', 'field', 'timeid', 'pathogen_cell_id']).size().reset_index(name='parasite_count')
+    parasite_counts = pathogen_df.groupby(['plate', 'row_name', 'column_name', 'field', 'timeid', 'pathogen_cell_id']).size().reset_index(name='parasite_count')
 
     # Aggregate numerical columns and take the first of object columns
-    agg_funcs = {col: 'mean' if np.issubdtype(pathogen_df[col].dtype, np.number) else 'first' for col in pathogen_df.columns if col not in ['plate', 'row', 'col', 'field', 'timeid', 'pathogen_cell_id', 'parasite_count']}
-    pathogen_agg = pathogen_df.groupby(['plate', 'row', 'col', 'field', 'timeid', 'pathogen_cell_id']).agg(agg_funcs).reset_index()
+    agg_funcs = {col: 'mean' if np.issubdtype(pathogen_df[col].dtype, np.number) else 'first' for col in pathogen_df.columns if col not in ['plate', 'row_name', 'column_name', 'field', 'timeid', 'pathogen_cell_id', 'parasite_count']}
+    pathogen_agg = pathogen_df.groupby(['plate', 'row_name', 'column_name', 'field', 'timeid', 'pathogen_cell_id']).agg(agg_funcs).reset_index()
 
     # Merge the counts back into the aggregated data
-    pathogen_agg = pathogen_agg.merge(parasite_counts, on=['plate', 'row', 'col', 'field', 'timeid', 'pathogen_cell_id'])
+    pathogen_agg = pathogen_agg.merge(parasite_counts, on=['plate', 'row_name', 'column_name', 'field', 'timeid', 'pathogen_cell_id'])
 
     # Remove the object_label column as it corresponds to the pathogen ID not the cell ID
     if 'object_label' in pathogen_agg.columns:
@@ -604,10 +604,10 @@ def save_results_dataframe(df, src, results_name):
 def summarize_per_well(peak_details_df):
     # Step 1: Split the 'ID' column
     split_columns = peak_details_df['ID'].str.split('_', expand=True)
-    peak_details_df[['plate', 'row', 'column', 'field', 'object_number']] = split_columns
+    peak_details_df[['plate', 'row_name', 'column', 'field', 'object_number']] = split_columns
 
-    # Step 2: Create 'well_ID' by combining 'row' and 'column'
-    peak_details_df['well_ID'] = peak_details_df['row'] + '_' + peak_details_df['column']
+    # Step 2: Create 'well_ID' by combining 'row_name' and 'column'
+    peak_details_df['well_ID'] = peak_details_df['row_name'] + '_' + peak_details_df['column']
 
     # Filter entries where 'amplitude' is not null
     filtered_df = peak_details_df[peak_details_df['amplitude'].notna()]
@@ -635,10 +635,10 @@ def summarize_per_well(peak_details_df):
 def summarize_per_well_inf_non_inf(peak_details_df):
     # Step 1: Split the 'ID' column
     split_columns = peak_details_df['ID'].str.split('_', expand=True)
-    peak_details_df[['plate', 'row', 'column', 'field', 'object_number']] = split_columns
+    peak_details_df[['plate', 'row_name', 'column', 'field', 'object_number']] = split_columns
 
-    # Step 2: Create 'well_ID' by combining 'row' and 'column'
-    peak_details_df['well_ID'] = peak_details_df['row'] + '_' + peak_details_df['column']
+    # Step 2: Create 'well_ID' by combining 'row_name' and 'column'
+    peak_details_df['well_ID'] = peak_details_df['row_name'] + '_' + peak_details_df['column']
 
     # Assume 'pathogen_count' indicates infection if > 0
     # Add an 'infected_status' column to classify cells
@@ -669,7 +669,7 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
         pathogen_df = pd.read_sql("SELECT * FROM pathogen", conn)
         pathogen_df['pathogen_cell_id'] = pathogen_df['pathogen_cell_id'].astype(float).astype('Int64')
         pathogen_df = preprocess_pathogen_data(pathogen_df)
-        cell_df = cell_df.merge(pathogen_df, on=['plate', 'row', 'col', 'field', 'timeid', 'object_label'], how='left', suffixes=('', '_pathogen'))
+        cell_df = cell_df.merge(pathogen_df, on=['plate', 'row_name', 'column_name', 'field', 'timeid', 'object_label'], how='left', suffixes=('', '_pathogen'))
         cell_df['parasite_count'] = cell_df['parasite_count'].fillna(0)
         print(f'After pathogen merge: {len(cell_df)} objects')
 
@@ -677,7 +677,7 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
     if cytoplasm:
         cytoplasm_df = pd.read_sql(f"SELECT * FROM {'cytoplasm'}", conn)
         # Merge on specified columns
-        cell_df = cell_df.merge(cytoplasm_df, on=['plate', 'row', 'col', 'field', 'timeid', 'object_label'], how='left', suffixes=('', '_cytoplasm'))
+        cell_df = cell_df.merge(cytoplasm_df, on=['plate', 'row_name', 'column_name', 'field', 'timeid', 'object_label'], how='left', suffixes=('', '_cytoplasm'))
 
         print(f'After cytoplasm merge: {len(cell_df)} objects')
     
@@ -687,12 +687,12 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
     # Prepare DataFrame (use cell_df instead of df)
     prcf_components = cell_df['prcf'].str.split('_', expand=True)
     cell_df['plate'] = prcf_components[0]
-    cell_df['row'] = prcf_components[1]
+    cell_df['row_name'] = prcf_components[1]
     cell_df['column'] = prcf_components[2]
     cell_df['field'] = prcf_components[3]
     cell_df['time'] = prcf_components[4].str.extract('t(\d+)').astype(int)
     cell_df['object_number'] = cell_df['object_label']
-    cell_df['plate_row_column_field_object'] = cell_df['plate'].astype(str) + '_' + cell_df['row'].astype(str) + '_' + cell_df['column'].astype(str) + '_' + cell_df['field'].astype(str) + '_' + cell_df['object_label'].astype(str)
+    cell_df['plate_row_column_field_object'] = cell_df['plate'].astype(str) + '_' + cell_df['row_name'].astype(str) + '_' + cell_df['column'].astype(str) + '_' + cell_df['field'].astype(str) + '_' + cell_df['object_label'].astype(str)
 
     df = cell_df.copy()
 
@@ -753,7 +753,7 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
                 peak_details_list.append({
                     'ID': unique_id,
                     'plate': group['plate'].iloc[0],
-                    'row': group['row'].iloc[0],
+                    'row_name': group['row_name'].iloc[0],
                     'column': group['column'].iloc[0],
                     'field': group['field'].iloc[0],
                     'object_number': group['object_number'].iloc[0],
@@ -784,7 +784,7 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
                 peak_details_list.append({
                     'ID': unique_id,
                     'plate': group['plate'].iloc[0],
-                    'row': group['row'].iloc[0],
+                    'row_name': group['row_name'].iloc[0],
                     'column': group['column'].iloc[0],
                     'field': group['field'].iloc[0],
                     'object_number': group['object_number'].iloc[0],

spacr/toxo.py

@@ -468,15 +468,15 @@ def generate_score_heatmap(settings):
     def group_cv_score(csv, plate=1, column='c3', data_column='pred'):
         
         df = pd.read_csv(csv)
-        if 'col' in df.columns:
-            df = df[df['col']==column]
+        if 'column_name' in df.columns:
+            df = df[df['column_name']==column]
         elif 'column' in df.columns:
-            df['col'] = df['column']
-            df = df[df['col']==column]
+            df['column_name'] = df['column']
+            df = df[df['column_name']==column]
         if not plate is None:
             df['plate'] = f"plate{plate}"
-        grouped_df = df.groupby(['plate', 'row', 'col'])[data_column].mean().reset_index()
-        grouped_df['prc'] = grouped_df['plate'].astype(str) + '_' + grouped_df['row'].astype(str) + '_' + grouped_df['col'].astype(str)
+        grouped_df = df.groupby(['plate', 'row_name', 'column_name'])[data_column].mean().reset_index()
+        grouped_df['prc'] = grouped_df['plate'].astype(str) + '_' + grouped_df['row_name'].astype(str) + '_' + grouped_df['column_name'].astype(str)
         return grouped_df
 
     def calculate_fraction_mixed_condition(csv, plate=1, column='c3', control_sgrnas = ['TGGT1_220950_1', 'TGGT1_233460_4']):
@@ -501,17 +501,17 @@ def generate_score_heatmap(settings):
         - column: Column to filter by (default is 'c3').
         """
         # Extract row number and convert to integer for sorting
-        df['row_num'] = df['row'].str.extract(r'(\d+)').astype(int)
+        df['row_num'] = df['row_name'].str.extract(r'(\d+)').astype(int)
 
         # Filter and sort by plate, row, and column
-        df = df[df['col'] == column]
-        df = df.sort_values(by=['plate', 'row_num', 'col'])
+        df = df[df['column_name'] == column]
+        df = df.sort_values(by=['plate', 'row_num', 'column_name'])
 
         # Drop temporary 'row_num' column after sorting
         df = df.drop('row_num', axis=1)
 
         # Create a new column combining plate, row, and column for the index
-        df['plate_row_col'] = df['plate'] + '-' + df['row'] + '-' + df['col']
+        df['plate_row_col'] = df['plate'] + '-' + df['row_name'] + '-' + df['column_name']
 
         # Set 'plate_row_col' as the index
         df.set_index('plate_row_col', inplace=True)
@@ -568,11 +568,11 @@ def generate_score_heatmap(settings):
         # Loop through all collected CSV files and process them
         for csv_file in ls:
             df = pd.read_csv(csv_file)  # Read CSV into DataFrame
-            df = df[df['col']==column]
+            df = df[df['column_name']==column]
             if not plate is None:
                 df['plate'] = f"plate{plate}"
-            # Group the data by 'plate', 'row', and 'col'
-            grouped_df = df.groupby(['plate', 'row', 'col'])[data_column].mean().reset_index()
+            # Group the data by 'plate', 'row_name', and 'column_name'
+            grouped_df = df.groupby(['plate', 'row_name', 'column_name'])[data_column].mean().reset_index()
             # Use the CSV filename to create a new column name
             folder_name = os.path.dirname(csv_file).replace(".csv", "")
             new_column_name = os.path.basename(f"{folder_name}_{data_column}")
@@ -583,8 +583,8 @@ def generate_score_heatmap(settings):
             if combined_df is None:
                 combined_df = grouped_df
             else:
-                combined_df = pd.merge(combined_df, grouped_df, on=['plate', 'row', 'col'], how='outer')
-        combined_df['prc'] = combined_df['plate'].astype(str) + '_' + combined_df['row'].astype(str) + '_' + combined_df['col'].astype(str)
+                combined_df = pd.merge(combined_df, grouped_df, on=['plate', 'row_name', 'column_name'], how='outer')
+        combined_df['prc'] = combined_df['plate'].astype(str) + '_' + combined_df['row_name'].astype(str) + '_' + combined_df['column_name'].astype(str)
         return combined_df
     
     def calculate_mae(df):