FIX2

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

Author: f3sch

Detectors/ITSMFT/ITS/macros/test/optimize_vertexer.py

@@ -144,7 +144,9 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--input-line-cap-factor", type=float, default=1.5, help="Maximum allowed factor increase in total lines for input-stage trials")
     parser.add_argument("--input-fake-line-cap-factor", type=float, default=1.5, help="Maximum allowed factor increase in fake lines for input-stage trials")
     parser.add_argument("--input-fake-line-cap-add", type=int, default=200, help="Minimum additive fake-line allowance for input-stage trials")
+    parser.add_argument("--failed-trial-score", type=float, default=-1.0, help="Objective value assigned to trials whose workflow fails")
     parser.add_argument("--artifact-dir", type=Path, default=Path(".vertex_optuna"), help="Directory for trial workflows and summaries")
+    parser.add_argument("--run-tracking", action="store_true", help="Run ITS tracking after vertexing instead of using vertexer-only trials")
     parser.add_argument("--dry-run", action="store_true", help="Patch and print one trial setup without running")
     return parser.parse_args()
 
@@ -462,13 +464,16 @@ def patch_workflow_for_trial(
     workflow: dict[str, Any],
     task_tag: str,
     overrides: dict[str, Any],
+    run_tracking: bool = False,
 ) -> dict[str, Any]:
     patched = json.loads(json.dumps(workflow))
     _, patched_tasks = load_workflow_from_object(patched)
     prefix = f"{task_tag}_"
     full_overrides = dict(overrides)
     full_overrides["ITSVertexerParam.nIterations"] = 2
     full_overrides["ITSCATrackerParam.doUPCIteration"] = 1
+    if not run_tracking:
+        full_overrides["ITSCATrackerParam.nIterations"] = 0
     for task in patched_tasks:
         name = str(task.get("name", ""))
         if not name.startswith(prefix):
@@ -530,8 +535,9 @@ def evaluate_trial(
     trial_name: str,
     overrides: dict[str, Any],
     selected_tasks: list[TaskInfo],
+    run_tracking: bool,
 ) -> dict[str, Any]:
-    patched = patch_workflow_for_trial(workflow, task_tag, overrides)
+    patched = patch_workflow_for_trial(workflow, task_tag, overrides, run_tracking)
     workflow_copy = artifact_dir / f"{trial_name}_workflow.json"
     with workflow_copy.open("w") as stream:
         json.dump(patched, stream, indent=2)
@@ -573,7 +579,7 @@ def main() -> int:
     if args.dry_run:
         specs = INPUT_STAGE_SPECS if args.stage == "input" else VERTEX_STAGE_SPECS
         dry_overrides = {spec.key: base_params[spec.key] for spec in specs}
-        patched = patch_workflow_for_trial(workflow, args.task_tag, dry_overrides)
+        patched = patch_workflow_for_trial(workflow, args.task_tag, dry_overrides, args.run_tracking)
         workflow_copy = artifact_dir / "dry_run_workflow.json"
         with workflow_copy.open("w") as stream:
             json.dump(patched, stream, indent=2)
@@ -594,6 +600,7 @@ def main() -> int:
         trial_name="baseline",
         overrides={},
         selected_tasks=selected_tasks,
+        run_tracking=args.run_tracking,
     )
     print(f"Baseline: {summarize_result(baseline_metrics)}")
 
@@ -608,18 +615,25 @@ def main() -> int:
 
     def objective(trial: optuna.Trial) -> float:
         overrides = suggest_params(trial, args.stage, base_params)
-        metrics = evaluate_trial(
-            workflow=workflow,
-            task_tag=args.task_tag,
-            run_dir=run_dir,
-            runner=runner,
-            artifact_dir=artifact_dir,
-            trial_name=f"trial_{trial.number:04d}",
-            overrides=overrides,
-            selected_tasks=selected_tasks,
-        )
         for key, value in overrides.items():
             trial.set_user_attr(key, value)
+        try:
+            metrics = evaluate_trial(
+                workflow=workflow,
+                task_tag=args.task_tag,
+                run_dir=run_dir,
+                runner=runner,
+                artifact_dir=artifact_dir,
+                trial_name=f"trial_{trial.number:04d}",
+                overrides=overrides,
+                selected_tasks=selected_tasks,
+                run_tracking=args.run_tracking,
+            )
+        except (subprocess.CalledProcessError, RuntimeError) as exc:
+            trial.set_user_attr("workflow_failed", True)
+            trial.set_user_attr("failure", str(exc))
+            print(f"Trial {trial.number}: workflow failed -> {exc}")
+            return args.failed_trial_score
         for key in ("line_findable", "true_lines", "fake_lines", "total_lines", "unique_truth_ge2_lines",
                     "findable", "true_found", "unique_true_findable", "unique_true_all", "total_found",
                     "line_eff", "eff", "purity", "fake_rate", "duplicate_rate", "f1", "elapsed_ms"):
@@ -643,7 +657,7 @@ def objective(trial: optuna.Trial) -> float:
                 trial.set_user_attr("guardrail_failed", True)
                 trial.set_user_attr("guardrail_violations", ",".join(input_guardrail_violations))
                 print(f"Trial {trial.number}: guardrail failed ({', '.join(input_guardrail_violations)}) -> {summarize_result(metrics)}")
-                return -1.0
+                return args.failed_trial_score
 
         violations = []
         baseline_eff_bins = baseline_metrics["line_eff_bins"] if args.stage == "input" else baseline_metrics["eff_bins"]
@@ -665,7 +679,7 @@ def objective(trial: optuna.Trial) -> float:
             trial.set_user_attr("guardrail_failed", True)
             trial.set_user_attr("guardrail_violations", ",".join(violations))
             print(f"Trial {trial.number}: guardrail failed ({', '.join(violations)}) -> {summarize_result(metrics)}")
-            return -1.0
+            return args.failed_trial_score
 
         print(f"Trial {trial.number}: {summarize_result(metrics)}")
         return metrics["line_eff"] if args.stage == "input" else metrics["f1"]

Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx

@@ -264,7 +264,7 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
   if (trackParams.size() > tc.nIterations) {
     trackParams.resize(tc.nIterations);
   }
-
+  trackParams.resize(0);
   return trackParams;
 }
 

Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx

@@ -198,13 +198,13 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
     return;
   }
 
-  if (mOverrideBeamEstimation) {
-    mTimeFrame->setBeamPosition(mMeanVertex->getX(),
-                                mMeanVertex->getY(),
-                                mMeanVertex->getSigmaY2(),
-                                mTracker->getParameters()[0].LayerResolution[0],
-                                mTracker->getParameters()[0].SystErrorY2[0]);
-  }
+  const TrackingParameters defaultTrackingParams;
+  const auto& trackParams = mTracker->getParameters();
+  const auto& beamParams = trackParams.empty() ? defaultTrackingParams : trackParams[0];
+  mTimeFrame->setBeamPosition(-0.050641048699617386, -0.02497512847185135,
+                              3.405e-06,
+                              beamParams.LayerResolution[0],
+                              beamParams.SystErrorY2[0]);
 
   mTracker->setBz(o2::base::Propagator::Instance()->getNominalBz());
   mTracker->setTimeSlice(tfInfo.timeslice);
@@ -443,7 +443,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
     LOG(info) << fmt::format(" + Beam position computed for the TF: {}, {}", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
   }
 
-  if (hasClusters) {
+  if (hasClusters && !mTracker->getParameters().empty()) {
     mTimeFrame->setMultiplicityCutMask(processMultiplictyMask);
     mTimeFrame->setUPCCutMask(processUPCMask);
     if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
@@ -452,6 +452,8 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       trackerElapsedTime = mTracker->clustersToTracks(logger, errorLogger);
     }
     LOGP(info, " + Tracking total elapse time: {} ms for {} tracks found", trackerElapsedTime, mTimeFrame->getNumberOfTracks());
+  } else if (hasClusters) {
+    LOGP(info, " + Tracking skipped: no tracking iterations configured");
   }
   if constexpr (constants::DoTimeBenchmarks) {
     const auto& trackConf = o2::its::TrackerParamConfig::Instance();