docs: rename ProcessedData to entity-oriented names across docs

- SessionAnalysis: handle-errors, distributed-computing, monitor-progress,
  alter-tables, delete-data, job-metadata, data-manipulation,
  table-declaration, type-system (blob example)
- FilteredTrace: use-npy-codec (FFT computation on raw traces)
- RecordingAnalysis: type-system explanation (object@ storage)
- Pipeline example: RawData/Analysis -> Session/TrialStats

Only the 03-data-entry tutorial notebook retains ProcessedData
(self-contained tutorial with its own schema).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dimitri-yatsenko

src/explanation/type-system.md

@@ -269,7 +269,7 @@ result = np.mean(ref)  # Downloads automatically
 Schema-addressed storage for files and folders. Path mirrors the database structure: `{schema}/{table}/{pk}/{attribute}`.
 
 ```python
-class ProcessedData(dj.Computed):
+class RecordingAnalysis(dj.Computed):
     definition = """
     -> Recording
     ---

src/how-to/alter-tables.md

@@ -199,10 +199,10 @@ For tables created before enabling job metadata:
 from datajoint.migrate import add_job_metadata_columns
 
 # Dry run
-add_job_metadata_columns(ProcessedData, dry_run=True)
+add_job_metadata_columns(SessionAnalysis, dry_run=True)
 
 # Apply
-add_job_metadata_columns(ProcessedData, dry_run=False)
+add_job_metadata_columns(SessionAnalysis, dry_run=False)
 ```
 
 ## Best Practices

src/how-to/delete-data.md

@@ -175,7 +175,7 @@ with dj.conn().transaction:
     Session.Trial.insert(corrected_trials)
 
 # 3. Recompute derived data
-ProcessedData.populate()
+SessionAnalysis.populate()
 ```
 
 This ensures all derived data remains consistent with source data.

src/how-to/distributed-computing.md

@@ -8,10 +8,10 @@ Use `reserve_jobs=True` to enable job coordination:
 
 ```python
 # Single worker (default)
-ProcessedData.populate()
+SessionAnalysis.populate()
 
 # Distributed mode with job reservation
-ProcessedData.populate(reserve_jobs=True)
+SessionAnalysis.populate(reserve_jobs=True)
 ```
 
 ## How It Works
@@ -26,7 +26,7 @@ With `reserve_jobs=True`:
 
 ```python
 # Use multiple processes
-ProcessedData.populate(reserve_jobs=True, processes=4)
+SessionAnalysis.populate(reserve_jobs=True, processes=4)
 ```
 
 Each process:
@@ -42,10 +42,10 @@ Run the same script on multiple machines:
 ```python
 # worker_script.py - run on each machine
 import datajoint as dj
-from my_pipeline import ProcessedData
+from my_pipeline import SessionAnalysis
 
 # Each worker reserves and processes different jobs
-ProcessedData.populate(
+SessionAnalysis.populate(
     reserve_jobs=True,
     display_progress=True,
     suppress_errors=True
@@ -60,13 +60,13 @@ Each auto-populated table has a jobs table (`~~table_name`):
 
 ```python
 # View job status
-ProcessedData.jobs
+SessionAnalysis.jobs
 
 # Filter by status
-ProcessedData.jobs.pending
-ProcessedData.jobs.reserved
-ProcessedData.jobs.errors
-ProcessedData.jobs.completed
+SessionAnalysis.jobs.pending
+SessionAnalysis.jobs.reserved
+SessionAnalysis.jobs.errors
+SessionAnalysis.jobs.completed
 ```
 
 ## Job Statuses
@@ -85,7 +85,7 @@ Sync the job queue with current key_source:
 
 ```python
 # Add new pending jobs, remove stale ones
-result = ProcessedData.jobs.refresh()
+result = SessionAnalysis.jobs.refresh()
 print(f"Added: {result['added']}, Removed: {result['removed']}")
 ```
 
@@ -95,10 +95,10 @@ Control processing order with priorities:
 
 ```python
 # Refresh with specific priority
-ProcessedData.jobs.refresh(priority=1)  # Lower = more urgent
+SessionAnalysis.jobs.refresh(priority=1)  # Lower = more urgent
 
 # Process only high-priority jobs
-ProcessedData.populate(reserve_jobs=True, priority=3)
+SessionAnalysis.populate(reserve_jobs=True, priority=3)
 ```
 
 ## Error Recovery
@@ -107,13 +107,13 @@ Handle failed jobs:
 
 ```python
 # View errors
-errors = ProcessedData.jobs.errors
+errors = SessionAnalysis.jobs.errors
 for job in errors.to_dicts():
     print(f"Key: {job}, Error: {job['error_message']}")
 
 # Clear errors to retry
 errors.delete()
-ProcessedData.populate(reserve_jobs=True)
+SessionAnalysis.populate(reserve_jobs=True)
 ```
 
 ## Orphan Detection
@@ -122,7 +122,7 @@ Jobs from crashed workers are automatically recovered:
 
 ```python
 # Refresh with orphan timeout (seconds)
-ProcessedData.jobs.refresh(orphan_timeout=3600)
+SessionAnalysis.jobs.refresh(orphan_timeout=3600)
 ```
 
 Reserved jobs older than the timeout are reset to pending.
@@ -172,10 +172,10 @@ dj.config.jobs.version_method = "git"
 
 # worker.py - run on each node
 from config import *
-from my_pipeline import ProcessedData
+from my_pipeline import SessionAnalysis
 
 while True:
-    result = ProcessedData.populate(
+    result = SessionAnalysis.populate(
         reserve_jobs=True,
         max_calls=100,
         suppress_errors=True,

src/how-to/handle-errors.md

@@ -8,10 +8,10 @@ Continue processing despite individual failures:
 
 ```python
 # Stop on first error (default)
-ProcessedData.populate()
+SessionAnalysis.populate()
 
 # Log errors but continue
-ProcessedData.populate(suppress_errors=True)
+SessionAnalysis.populate(suppress_errors=True)
 ```
 
 ## View Failed Jobs
@@ -20,10 +20,10 @@ Check the jobs table for errors:
 
 ```python
 # All error jobs
-ProcessedData.jobs.errors
+SessionAnalysis.jobs.errors
 
 # View error details
-for job in ProcessedData.jobs.errors.to_dicts():
+for job in SessionAnalysis.jobs.errors.to_dicts():
     print(f"Key: {job}")
     print(f"Message: {job['error_message']}")
 ```
@@ -33,7 +33,7 @@ for job in ProcessedData.jobs.errors.to_dicts():
 Error stack traces are stored in the jobs table:
 
 ```python
-job = (ProcessedData.jobs.errors & key).fetch1()
+job = (SessionAnalysis.jobs.errors & key).fetch1()
 print(job['error_stack'])
 ```
 
@@ -43,10 +43,10 @@ Clear error status and rerun:
 
 ```python
 # Delete error records to retry
-ProcessedData.jobs.errors.delete()
+SessionAnalysis.jobs.errors.delete()
 
 # Reprocess
-ProcessedData.populate(reserve_jobs=True)
+SessionAnalysis.populate(reserve_jobs=True)
 ```
 
 ## Retry Specific Jobs
@@ -55,10 +55,10 @@ Target specific failed jobs:
 
 ```python
 # Clear one error
-(ProcessedData.jobs & key & "status='error'").delete()
+(SessionAnalysis.jobs & key & "status='error'").delete()
 
 # Retry just that key
-ProcessedData.populate(key, reserve_jobs=True)
+SessionAnalysis.populate(key, reserve_jobs=True)
 ```
 
 ## Ignore Problematic Jobs
@@ -67,10 +67,10 @@ Mark jobs to skip permanently:
 
 ```python
 # Mark job as ignored
-ProcessedData.jobs.ignore(key)
+SessionAnalysis.jobs.ignore(key)
 
 # View ignored jobs
-ProcessedData.jobs.ignored
+SessionAnalysis.jobs.ignored
 ```
 
 ## Error Handling in make()
@@ -79,16 +79,16 @@ Handle expected errors gracefully:
 
 ```python
 @schema
-class ProcessedData(dj.Computed):
+class SessionAnalysis(dj.Computed):
     definition = """
-    -> RawData
+    -> Session
     ---
     result : float64
     """
 
     def make(self, key):
         try:
-            data = (RawData & key).fetch1('data')
+            data = (Session & key).fetch1('data')
             result = risky_computation(data)
         except ValueError as e:
             # Log and skip this key
@@ -117,7 +117,7 @@ def make(self, key):
 Get exception objects for programmatic handling:
 
 ```python
-result = ProcessedData.populate(
+result = SessionAnalysis.populate(
     suppress_errors=True,
     return_exception_objects=True
 )
@@ -133,7 +133,7 @@ for key, exception in result['error_list']:
 Track errors over time:
 
 ```python
-progress = ProcessedData.jobs.progress()
+progress = SessionAnalysis.jobs.progress()
 print(f"Pending: {progress.get('pending', 0)}")
 print(f"Errors: {progress.get('error', 0)}")
 print(f"Success: {progress.get('success', 0)}")

src/how-to/monitor-progress.md

@@ -7,7 +7,7 @@ Track computation progress and job status.
 Show progress bar during populate:
 
 ```python
-ProcessedData.populate(display_progress=True)
+SessionAnalysis.populate(display_progress=True)
 ```
 
 ## Check Remaining Work
@@ -16,7 +16,7 @@ Count entries left to compute:
 
 ```python
 # What's left to compute
-remaining = ProcessedData.key_source - ProcessedData
+remaining = SessionAnalysis.key_source - SessionAnalysis
 print(f"{len(remaining)} entries remaining")
 ```
 
@@ -25,7 +25,7 @@ print(f"{len(remaining)} entries remaining")
 Get counts by status:
 
 ```python
-progress = ProcessedData.jobs.progress()
+progress = SessionAnalysis.jobs.progress()
 # {'pending': 100, 'reserved': 5, 'error': 3, 'success': 892}
 
 for status, count in progress.items():
@@ -38,19 +38,19 @@ Access jobs by their current status:
 
 ```python
 # Pending jobs (waiting to run)
-ProcessedData.jobs.pending
+SessionAnalysis.jobs.pending
 
 # Currently running
-ProcessedData.jobs.reserved
+SessionAnalysis.jobs.reserved
 
 # Failed jobs
-ProcessedData.jobs.errors
+SessionAnalysis.jobs.errors
 
 # Completed jobs (if keep_completed=True)
-ProcessedData.jobs.completed
+SessionAnalysis.jobs.completed
 
 # Skipped jobs
-ProcessedData.jobs.ignored
+SessionAnalysis.jobs.ignored
 ```
 
 ## View Job Details
@@ -59,10 +59,10 @@ Inspect specific jobs:
 
 ```python
 # All jobs for a key
-(ProcessedData.jobs & key).fetch1()
+(SessionAnalysis.jobs & key).fetch1()
 
 # Recent errors
-ProcessedData.jobs.errors.to_dicts(
+SessionAnalysis.jobs.errors.to_dicts(
     order_by='completed_time DESC',
     limit=10
 )
@@ -73,7 +73,7 @@ ProcessedData.jobs.errors.to_dicts(
 See which workers are processing:
 
 ```python
-for job in ProcessedData.jobs.reserved.to_dicts():
+for job in SessionAnalysis.jobs.reserved.to_dicts():
     print(f"Key: {job}")
     print(f"Host: {job['host']}")
     print(f"PID: {job['pid']}")
@@ -86,7 +86,7 @@ Track how long jobs take:
 
 ```python
 # Average duration of completed jobs
-completed = ProcessedData.jobs.completed.to_arrays('duration')
+completed = SessionAnalysis.jobs.completed.to_arrays('duration')
 print(f"Average: {np.mean(completed):.1f}s")
 print(f"Median: {np.median(completed):.1f}s")
 ```
@@ -112,10 +112,10 @@ This adds hidden attributes to computed tables:
 
 ```python
 import time
-from my_pipeline import ProcessedData
+from my_pipeline import SessionAnalysis
 
 while True:
-    remaining, total = ProcessedData.progress()
+    remaining, total = SessionAnalysis.progress()
 
     print(f"\rProgress: {total - remaining}/{total} ({(total - remaining) / total:.0%})", end='')
 
@@ -130,10 +130,10 @@ For distributed mode with job tracking:
 
 ```python
 import time
-from my_pipeline import ProcessedData
+from my_pipeline import SessionAnalysis
 
 while True:
-    status = ProcessedData.jobs.progress()
+    status = SessionAnalysis.jobs.progress()
 
     print(f"\rPending: {status.get('pending', 0)} | "
           f"Running: {status.get('reserved', 0)} | "
@@ -152,7 +152,7 @@ while True:
 Check multiple tables:
 
 ```python
-tables = [RawData, ProcessedData, Analysis]
+tables = [Session, SessionAnalysis, TrialStats]
 
 for table in tables:
     total = len(table.key_source)

src/how-to/use-npy-codec.md

@@ -159,7 +159,7 @@ for rec in large:
 
 ```python
 @schema
-class ProcessedData(dj.Computed):
+class FilteredTrace(dj.Computed):
     definition = """
     -> RawData
     ---

src/reference/specs/data-manipulation.md

@@ -357,7 +357,7 @@ About to delete:
   Subject: 1 rows
   Session: 5 rows
   Trial: 150 rows
-  ProcessedData: 150 rows
+  SessionAnalysis: 150 rows
 
 Commit deletes? [yes, No]:
 ```