|
14 | 14 | import re |
15 | 15 | from ROOT import o2 # for CCDB |
16 | 16 | import argparse |
| 17 | +import json |
17 | 18 | import sys |
18 | 19 |
|
19 | 20 | class lhc_constants: |
@@ -150,7 +151,8 @@ def find_tree_key(keys, pattern): |
150 | 151 |
|
151 | 152 | folders = { k.split("/")[0] : 1 for k in raw_keys if "O2bc_001" in k } |
152 | 153 | folders = [ k for k in folders.keys() ] |
153 | | - folders = folders[:max_folders] |
| 154 | + if max_folders is not None: |
| 155 | + folders = folders[:max_folders] |
154 | 156 |
|
155 | 157 | print ("have ", len(raw_keys), f" in file {filepath}") |
156 | 158 |
|
@@ -178,11 +180,15 @@ def find_tree_key(keys, pattern): |
178 | 180 |
|
179 | 181 | # do the actual timeframe structure calculation; we only take collisions with a trigger decision attached |
180 | 182 | triggered = combined[combined["fTriggerMask"] != 0] |
| 183 | + folderkey = folder + '@' + filepath |
| 184 | + if triggered.empty: |
| 185 | + # a DF without triggered collisions has no timeframe to embed |
| 186 | + merged[folderkey] = pd.DataFrame({'timeframeID': [], 'position_vectors': []}) |
| 187 | + continue |
181 | 188 | timeframe_structure = triggered.groupby('timeframeID').apply( |
182 | 189 | lambda g: list(zip(g['fGlobalBC'], g['fPosX'], g['fPosY'], g['fPosZ'], g['orbit'], g['bc_within_orbit'], g['fCollisionTime'])) |
183 | 190 | ).reset_index(name='position_vectors') |
184 | 191 |
|
185 | | - folderkey = folder + '@' + filepath |
186 | 192 | merged[folderkey] = timeframe_structure # data per folder |
187 | 193 | if include_dataframe: |
188 | 194 | merged["data"] = combined |
@@ -247,11 +253,21 @@ def fetch_bccoll_to_localFile(alien_file, local_filename): |
247 | 253 | return True |
248 | 254 |
|
249 | 255 |
|
| 256 | +def time_ordered_collisions(collisions): |
| 257 | + """ |
| 258 | + Sorts collisions (globalBC, x, y, z, orbit, bc, collisionTime[ns]) by their time, BC plus |
| 259 | + collision time. The digitizers need time-ordered interactions; the AO2D order is by BC only, |
| 260 | + and a negative collision time can move a collision before one in an earlier BC. |
| 261 | + """ |
| 262 | + return sorted(collisions, key=lambda c: c[0] * lhc_constants.LHCBunchSpacingNS + c[6]) |
| 263 | + |
| 264 | + |
250 | 265 | def convert_to_digicontext(aod_timeframe, df_folder, timeframeID=-1): |
251 | 266 | """ |
252 | 267 | converts AOD collision information from AO2D to collision context |
253 | 268 | which can be used for MC |
254 | 269 | """ |
| 270 | + aod_timeframe = time_ordered_collisions(aod_timeframe) |
255 | 271 | # we create the digitization context object |
256 | 272 | digicontext=o2.steer.DigitizationContext() |
257 | 273 |
|
@@ -301,44 +317,126 @@ def convert_to_digicontext(aod_timeframe, df_folder, timeframeID=-1): |
301 | 317 | digicontext.saveToFile(f"collission_context_{df_folder}:{timeframeID}.root") |
302 | 318 |
|
303 | 319 |
|
304 | | -def process_data_AO2D(file_name, run_number, upper_limit = -1): |
| 320 | +def units_from_timeframe_structure(merged): |
305 | 321 | """ |
306 | | - Creates all the collision contexts |
| 322 | + DF folder name -> sorted list of timeframe IDs with at least one triggered collision, |
| 323 | + from the output of get_timeframe_structure. A DF without such collisions maps to []. |
307 | 324 | """ |
308 | | - timeframe_data = [] |
| 325 | + units = {} |
| 326 | + for key, frame in merged.items(): |
| 327 | + df = key.split('@')[0] |
| 328 | + units[df] = sorted(int(tf) for tf in frame['timeframeID']) if len(frame) > 0 else [] |
| 329 | + return units |
309 | 330 |
|
310 | | - local_filename = "local.root" |
311 | | - fetch_bccoll_to_localFile(file_name, local_filename) |
312 | 331 |
|
313 | | - # fetch run_info object |
| 332 | +def select_folders(merged, dfs): |
| 333 | + """Restricts the get_timeframe_structure output to the given DF folder names.""" |
| 334 | + wanted = set(dfs) |
| 335 | + return {key: frame for key, frame in merged.items() if key.split('@')[0] in wanted} |
| 336 | + |
| 337 | + |
| 338 | +def expectation_mismatches(units, expected): |
| 339 | + """ |
| 340 | + Compares the timeframes found per DF with the ones the planner recorded. |
| 341 | + Returns a list of human-readable mismatches (empty when they agree). |
| 342 | + """ |
| 343 | + problems = [] |
| 344 | + for df in sorted(expected): |
| 345 | + if df not in units: |
| 346 | + problems.append(f"{df}: expected {sorted(expected[df])}, found none") |
| 347 | + elif sorted(units[df]) != sorted(expected[df]): |
| 348 | + problems.append(f"{df}: expected {sorted(expected[df])}, found {sorted(units[df])}") |
| 349 | + return problems |
| 350 | + |
| 351 | + |
| 352 | +def read_timeframe_structure(file_name, run_number): |
| 353 | + """Fetches the BC and collision tables of a (possibly remote) AO2D and returns the timeframe structure.""" |
| 354 | + local_filename = "local.root" |
| 355 | + if not fetch_bccoll_to_localFile(file_name, local_filename): |
| 356 | + raise RuntimeError(f"Could not fetch BC/collision tables from {file_name}") |
314 | 357 | run_info = retrieve_Aggregated_RunInfos(run_number) |
315 | | - merged = get_timeframe_structure(local_filename, run_info, max_folders=1000) |
| 358 | + return get_timeframe_structure(local_filename, run_info, max_folders=None) |
| 359 | + |
| 360 | + |
| 361 | +def units_from_file(file_name, run_number): |
| 362 | + """DF folder name -> list of timeframe IDs to embed, for one data AO2D.""" |
| 363 | + return units_from_timeframe_structure(read_timeframe_structure(file_name, run_number)) |
| 364 | + |
| 365 | + |
| 366 | +def set_context_interaction_rate(context_file, rate): |
| 367 | + """ |
| 368 | + Stores the interaction rate (Hz) in a collision context taken from data. The contexts built |
| 369 | + from data carry no rate, but the TPC looper generator and the digitizers read it from there. |
| 370 | + """ |
| 371 | + if rate <= 0: |
| 372 | + raise ValueError(f"invalid interaction rate {rate}") |
| 373 | + context = o2.steer.DigitizationContext.loadFromFile(context_file) |
| 374 | + context.setDigitizerInteractionRate(float(rate)) |
| 375 | + context.saveToFile(context_file) |
| 376 | + |
| 377 | + |
| 378 | +def process_data_AO2D(file_name, run_number, upper_limit = -1, dfs = None, expected = None): |
| 379 | + """ |
| 380 | + Creates the collision contexts, one per (DF folder, timeframe). |
| 381 | + dfs restricts this to the given DF folders; expected (DF -> timeframe IDs) is checked first |
| 382 | + and a disagreement exits with code 3, so a job never embeds something else than planned. |
| 383 | + """ |
| 384 | + merged = read_timeframe_structure(file_name, run_number) |
316 | 385 | print ("Got " + str(len(merged)) + " datasets") |
317 | | - timeframe_data.append(merged) |
| 386 | + if dfs is not None: |
| 387 | + merged = select_folders(merged, dfs) |
| 388 | + if expected is not None: |
| 389 | + problems = expectation_mismatches(units_from_timeframe_structure(merged), expected) |
| 390 | + if problems: |
| 391 | + for p in problems: |
| 392 | + print (f"ERROR: timeframe structure differs from the plan: {p}") |
| 393 | + sys.exit(3) |
318 | 394 |
|
319 | 395 | counter = 0 |
320 | | - for d in timeframe_data: |
321 | | - for key in d: |
322 | | - result = d[key] |
323 | | - for index, row in result.iterrows(): |
324 | | - if upper_limit >= 0 and counter >= upper_limit: |
325 | | - break |
326 | | - tf = row['timeframeID'] |
327 | | - cols = row['position_vectors'] |
328 | | - df = key.split('@')[0] # this is the DF folder name |
329 | | - convert_to_digicontext(cols, df, tf) |
330 | | - counter = counter + 1 |
| 396 | + for key in merged: |
| 397 | + result = merged[key] |
| 398 | + for index, row in result.iterrows(): |
| 399 | + if upper_limit >= 0 and counter >= upper_limit: |
| 400 | + break |
| 401 | + tf = row['timeframeID'] |
| 402 | + cols = row['position_vectors'] |
| 403 | + df = key.split('@')[0] # this is the DF folder name |
| 404 | + convert_to_digicontext(cols, df, tf) |
| 405 | + counter = counter + 1 |
331 | 406 |
|
332 | 407 |
|
333 | 408 | def main(): |
334 | 409 | parser = argparse.ArgumentParser(description='Extracts collision contexts from reconstructed AO2D') |
335 | 410 |
|
336 | | - parser.add_argument("--run-number", type=int, help="Run number to anchor to", required=True) |
337 | | - parser.add_argument("--aod-file", type=str, help="Data AO2D file (can be on AliEn)", required=True) |
| 411 | + parser.add_argument("--run-number", type=int, help="Run number to anchor to") |
| 412 | + parser.add_argument("--aod-file", type=str, help="Data AO2D file (can be on AliEn)") |
338 | 413 | parser.add_argument("--limit", type=int, default=-1, help="Upper limit of timeframes to be extracted (-1 is no limit)") |
| 414 | + parser.add_argument("--dfs", type=str, default=None, help="Comma-separated DF folders to treat (default: all)") |
| 415 | + parser.add_argument("--expect-tfs", type=str, default=None, help="JSON file DF -> timeframe IDs the plan expects; exit 3 on a difference") |
| 416 | + parser.add_argument("--list-units", type=str, default=None, help="Only write DF -> timeframe IDs as JSON to this file") |
| 417 | + parser.add_argument("--set-interaction-rate", type=float, default=None, help="Only store this interaction rate (Hz) in the contexts given by --context") |
| 418 | + parser.add_argument("--context", type=str, nargs="+", default=[], help="Collision context files for --set-interaction-rate") |
339 | 419 | args = parser.parse_args() |
340 | 420 |
|
341 | | - process_data_AO2D(args.aod_file, args.run_number, args.limit) |
| 421 | + if args.set_interaction_rate is not None: |
| 422 | + for c in args.context: |
| 423 | + set_context_interaction_rate(c, args.set_interaction_rate) |
| 424 | + return 0 |
| 425 | + if args.run_number is None or args.aod_file is None: |
| 426 | + parser.error("--run-number and --aod-file are required") |
| 427 | + |
| 428 | + if args.list_units: |
| 429 | + with open(args.list_units, "w") as f: |
| 430 | + json.dump(units_from_file(args.aod_file, args.run_number), f, indent=1) |
| 431 | + return 0 |
| 432 | + |
| 433 | + dfs = args.dfs.split(",") if args.dfs else None |
| 434 | + expected = None |
| 435 | + if args.expect_tfs: |
| 436 | + with open(args.expect_tfs) as f: |
| 437 | + expected = json.load(f) |
| 438 | + process_data_AO2D(args.aod_file, args.run_number, args.limit, dfs, expected) |
| 439 | + return 0 |
342 | 440 |
|
343 | 441 | if __name__ == "__main__": |
344 | 442 | sys.exit(main()) |
0 commit comments