3 from TriggerMenuMT.HLT.Config.Utility.MenuAlignmentTools
import get_alignment_group_ordering
as getAlignmentGroupOrdering
4 from TriggerMenuMT.HLT.Config.MenuComponents
import Chain, ChainStep, isEmptySequenceCfg, createEmptyMenuSequenceCfg
6 from AthenaCommon.Logging
import logging
7 from TrigCompositeUtils.TrigCompositeUtils
import legName
9 from itertools
import repeat
10 from copy
import deepcopy
13 log = logging.getLogger( __name__ )
15 def mergeChainDefs(listOfChainDefs, chainDict, perSig_lengthOfChainConfigs = None):
16 """ function to merge chain definitions for all legs, used also by signature code
17 chainDefList is a list of Chain() objects
18 one for each part (leg) in the chain """
20 strategy = chainDict[
"mergingStrategy"]
21 offset = chainDict[
"mergingOffset"]
22 log.debug(
"[mergeChainDefs] %s: Combine by using %s merging with %d chain defs (legs)", chainDict[
'chainName'], strategy, len(listOfChainDefs))
26 if 'Bjet' in chainDict[
'signatures']
and 'Jet' in chainDict[
'signatures']:
27 leg_numbering = [it
for it,s
in enumerate(chainDict[
'signatures'])]
29 if strategy==
"parallel":
31 elif strategy==
"serial":
34 elif strategy==
"auto":
35 ordering = getAlignmentGroupOrdering()
37 for ich,cConfig
in enumerate(listOfChainDefs):
38 chain_ag = cConfig.alignmentGroups[0]
39 if chain_ag
not in ordering:
40 log.error(
"[mergeChainDefs] Alignment group %s can't be auto-merged because it's not in the grouping list!",chain_ag)
41 if chain_ag
in merging_dict:
42 merging_dict[chain_ag] += [ich]
44 merging_dict[chain_ag] = [ich]
47 tmp_merged_ordering = []
48 for ag
in merging_dict:
49 if len(merging_dict[ag]) > 1:
50 log.debug(
"[mergeChainDefs] parallel merging")
51 new_chain_defs, perSig_lengthOfChainConfigs =
mergeParallel(
list( listOfChainDefs[i]
for i
in merging_dict[ag] ), offset, leg_numbering, perSig_lengthOfChainConfigs)
52 tmp_merged += [new_chain_defs]
53 tmp_merged_ordering += [ordering.index(ag)]
55 log.debug(
"[mergeChainDefs] don't need to parallel merge")
56 tmp_merged += [listOfChainDefs[merging_dict[ag][0]]]
57 tmp_merged_ordering += [ordering.index(ag)]
60 merged_ordering = [-1]*len(tmp_merged_ordering)
61 copy_ordering = tmp_merged_ordering.copy()
63 while len(copy_ordering) > 0:
64 min_index = tmp_merged_ordering.index(
min(copy_ordering))
65 copy_ordering.pop(copy_ordering.index(
min(copy_ordering)))
66 merged_ordering[min_index] = tmp_val
70 if len(tmp_merged) == 1:
71 if perSig_lengthOfChainConfigs
is None:
72 log.debug(
"[mergeChainDefs] tmp merged has length 1, returning 0th element")
75 log.debug(
"[mergeChainDefs] tmp merged has length 1, returning 0th element and perSig list")
76 return tmp_merged[0], perSig_lengthOfChainConfigs
78 if perSig_lengthOfChainConfigs
is None:
79 log.debug(
"[mergeChainDefs] serial merging first")
82 log.debug(
"[mergeChainDefs] returning mergeSerial result and perSig_lengthOfChainConfigs %s",perSig_lengthOfChainConfigs)
83 return mergeSerial(tmp_merged, merged_ordering), perSig_lengthOfChainConfigs
86 log.error(
"[mergeChainDefs] Merging failed for %s. Merging strategy '%s' not known.", (listOfChainDefs, strategy))
92 if not perSig_lengthOfChainConfigs:
95 for leg_lengths, leg_grps
in perSig_lengthOfChainConfigs:
96 for grp, length
in zip(leg_grps,leg_lengths):
97 if grp
in leg_length_dict:
98 leg_length_dict[grp] += [length]
100 leg_length_dict[grp] = [length]
101 found_mismatch =
False
104 log.debug(
"[check_leg_lengths] leg lengths: %s",leg_length_dict)
105 for grp,lengths
in leg_length_dict.items():
106 if len(
set(lengths)) > 1:
107 log.debug(
"[check_leg_lengths] found mismatch for %s given %s", grp, lengths)
109 log.error(
"[check_leg_lengths] Second mismatch in the same chain! I don't know how to deal with this, please resolve. Chain leg lengths: %s",perSig_lengthOfChainConfigs)
110 log.error(
"[check_leg_lengths] Second mismatch in the same chain! lengths,grp: %s,%s",lengths, grp)
111 raise Exception(
"[are_lengths_mismatched] Cannot merge chain, exiting.")
112 found_mismatch =
True
113 max_length =
max(lengths)
116 return mismatched_ag, max_length
119 def mergeParallel(chainDefList, offset, leg_numbering = None, perSig_lengthOfChainConfigs = None):
120 ''' Performs merging of steps with the same step number '''
122 if leg_numbering
is None: leg_numbering = []
125 log.error(
"[mergeParallel] Offset for parallel merging not implemented.")
126 raise Exception(
"[mergeParallel] Cannot merge this chain, exiting.")
128 log.debug(f
"[mergeParallel] Parallel merging for chain alignments {[cConfig.alignmentGroups for cConfig in chainDefList]}")
135 vertical_alignment_groups = []
137 for iConfig, cConfig
in enumerate(chainDefList):
139 chainName = cConfig.name
140 elif chainName != cConfig.name:
141 log.error(
"[mergeParallel] Something is wrong with the combined chain name: cConfig.name = %s while chainName = %s", cConfig.name, chainName)
142 raise Exception(
"[mergeParallel] Cannot merge this chain, exiting.")
144 if len(
set(cConfig.alignmentGroups)) == 1:
145 alignmentGroups.append(cConfig.alignmentGroups[0])
146 elif len(cConfig.alignmentGroups) > 1:
147 log.debug(
"[mergeParallel] Parallel merging an already merged chain with different alignment groups? This is odd! %s",cConfig.alignmentGroups)
148 log.debug(
"...let's look at the config: %s", perSig_lengthOfChainConfigs)
152 align_grp_to_lengthen, max_length =
check_leg_lengths(perSig_lengthOfChainConfigs)
154 current_leg_ag_length = -1
155 index_modified_leg = -1
156 leg_lengths, leg_ags = perSig_lengthOfChainConfigs[iConfig]
157 for ileg, (length, ag)
in enumerate(zip(leg_lengths, leg_ags)):
158 if ag == align_grp_to_lengthen:
159 current_leg_ag_length = length
160 index_modified_leg = ileg
161 log.debug(
"[mergeParallel] ileg %s, length %s, ag %s: ",ileg, length, ag)
166 n_new_steps = max_length - current_leg_ag_length
168 previous_step_dicts = cConfig.steps[current_leg_ag_length-1].stepDicts
169 for i
in range(1,n_new_steps+1):
173 for ileg,stepDict
in enumerate(previous_step_dicts):
174 is_fs_string =
'FS' if isFullScanRoI(cConfig.L1decisions[ileg])
else ''
175 sigNames += [stepDict[
'chainParts'][0][
'signature'] + is_fs_string]
177 seqMultName =
'_'.
join([sigName
for sigName
in sigNames])
181 seqNames = [
getEmptySeqName(previous_step_dicts[iSeq][
'signature'], current_leg_ag_length+i, align_grp_to_lengthen,i)
for iSeq
in range(len(sigNames))]
183 emptySequences =
build_empty_sequences(previous_step_dicts, step_mult,
'mergeParallel', cConfig.L1decisions, seqNames, chainName)
185 cConfig.steps.insert(current_leg_ag_length + i - 1,
186 ChainStep( seqStepName, SequenceGens = emptySequences,
187 chainDicts = previous_step_dicts)
192 perSig_lengthOfChainConfigs[iConfig][0][index_modified_leg] = max_length
194 log.debug(
"[mergeParallel] Alignment groups are empty for this combined chain")
196 allSteps.append(cConfig.steps)
198 allStepsMult.append(1)
199 nSteps.append(len(cConfig.steps))
200 l1Decisions.extend(cConfig.L1decisions)
205 if perSig_lengthOfChainConfigs
is not None and len(perSig_lengthOfChainConfigs) > 0:
206 in_chain_ag_lengths = {}
207 ag_ordering = getAlignmentGroupOrdering()
209 for ag
in ag_ordering:
210 for ag_lengths, sig_ags
in perSig_lengthOfChainConfigs:
211 for ag_length, sig_ag
in zip(ag_lengths, sig_ags):
212 if (sig_ag
in in_chain_ag_lengths
and in_chain_ag_lengths[sig_ag] < ag_length)
or sig_ag
not in in_chain_ag_lengths:
213 in_chain_ag_lengths[sig_ag] = ag_length
214 for ag, ag_length
in in_chain_ag_lengths.items():
215 vertical_alignment_groups += [ag]*ag_length
218 vertical_alignment_groups = [alignmentGroups[0]]*len(orderedSteps)
221 log.debug(
"[mergeParallel] alignment groups horizontal: %s", alignmentGroups)
222 log.debug(
"[mergeParallel] alignment groups vertical: %s", vertical_alignment_groups)
225 log.debug(
"[mergeParallel] len(orderedSteps): %d", len(orderedSteps))
226 for chain_index
in range(len(chainDefList)):
227 log.debug(
'[mergeParallel] Chain object to merge (i.e. chainDef) %s', chainDefList[chain_index])
229 for step_index, (steps, step_ag)
in enumerate(zip(orderedSteps,vertical_alignment_groups)):
230 mySteps =
list(steps)
231 log.debug(f
"[mergeParallel] Merging step {step_index+1} with alignment group = {step_ag}")
233 combStep =
makeCombinedStep(mySteps, step_index+1, chainDefList, orderedSteps, combChainSteps, leg_numbering, step_ag)
234 combChainSteps.append(combStep)
237 combinedChainDef = Chain(chainName, ChainSteps=combChainSteps, L1decisions=l1Decisions,
238 nSteps = nSteps, alignmentGroups = alignmentGroups)
240 log.debug(
"[mergeParallel] Parallel merged chain %s with these steps:", chainName)
241 for step
in combinedChainDef.steps:
242 log.debug(
'\n %s', step)
244 return combinedChainDef, perSig_lengthOfChainConfigs
247 currentStepName =
'Empty' + alignmentGroup +
'Align'+
str(stepNumber)+
'_'+
str(multiplicity) + signature
248 return currentStepName
252 seqName =
'Empty'+ alignGroup +
'Seq'+
str(step_number)+
'_'+
str(order) + signature
257 fsRoIList = [
'HLTNav_L1FSNOSEED',
'HLTNav_L1MET',
'HLTNav_L1J']
258 if inputL1Nav
in fsRoIList:
266 for iseq,seq
in enumerate(chainStep.sequenceGens):
274 if len(
set(cp[
'alignmentGroup']
for cp
in chainStep.stepDicts[iseq][
'chainParts'])) > 1:
275 log.error(
"[getCurrentAG] The leg has more than one chainPart (%s). Either the alignmentGroup property is bad or this is an unimplemented situation.",chainStep.stepDicts[iseq][
'chainParts'])
276 raise Exception(
"[getCurrentAG] Not sure what is happening here, but I don't know what to do.")
277 filled_seq_ag += [chainStep.stepDicts[iseq][
'chainParts'][0][
'alignmentGroup']]
279 if len(filled_seq_ag) == 0:
280 log.error(
"[getCurrentAG] No non-empty sequences were found in %s", chainStep.sequenceGens)
281 log.error(
"[getCurrentAG] The chainstep is %s", chainStep)
282 raise Exception(
"[getCurrentAG] Cannot find the current alignment group for this chain")
283 elif len(
set(filled_seq_ag)) > 1:
284 log.error(
"[getCurrentAG] Found more than one alignment group for this step %s", filled_seq_ag)
285 raise Exception(
"[getCurrentAG] Cannot find the current alignment group for this chain")
287 return filled_seq_ag[0]
289 def serial_zip(allSteps, chainName, chainDefList, legOrdering):
295 legs_per_part = [chainDefList[stepPlacement].steps[0].nLegs
for stepPlacement
in legOrdering]
296 n_parts = len(allSteps)
297 log.debug(
'[serial_zip] configuring chain with %d parts with multiplicities %s', n_parts, legs_per_part)
298 log.debug(
'[serial_zip] and leg ordering %s', legOrdering)
305 for chain_index, (chainSteps, stepPlacement)
in enumerate(zip(allSteps, legOrdering)):
307 for step_index, step
in enumerate(chainSteps):
309 prev_ag_step_index = step_index
311 log.debug(
'[serial_zip] chain_index: %s step_index: %s, alignment group: %s', chain_index, step_index+1, previousAG)
313 stepList = [
None]*n_parts
316 stepList[stepPlacement] = step
317 log.debug(
'[serial_zip] Put step: %s', step.name)
320 for chain_index2, (nLegs, stepPlacement2)
in enumerate(zip(legs_per_part, legOrdering)):
321 emptyStep = stepList[stepPlacement2]
322 if emptyStep
is None:
323 if chain_index2 == chain_index:
324 log.error(
"chain_index2 = chain_index, but the stepList still has none!")
325 raise Exception(
"[serial_zip] duplicating existing leg, why has this happened??")
330 if chain_index2 < chain_index:
331 emptyChainDicts = allSteps[chain_index2][-1].stepDicts
333 emptyChainDicts = allSteps[chain_index2][0].stepDicts
335 log.debug(
"[serial_zip] nLegs: %s, len(emptyChainDicts): %s, len(L1decisions): %s", nLegs, len(emptyChainDicts), len(chainDefList[stepPlacement2].L1decisions))
337 for ileg,(emptyChainDict,_)
in enumerate(zip(emptyChainDicts,chainDefList[stepPlacement2].L1decisions)):
338 is_fs_string =
'FS' if isFullScanRoI(chainDefList[stepPlacement2].L1decisions[ileg])
else ''
339 sigNames +=[emptyChainDict[
'chainParts'][0][
'signature']+is_fs_string]
342 seqMultName =
'_'.
join([sigName
for sigName
in sigNames])
346 if len(
set(chainDefList[stepPlacement].alignmentGroups)) == 1:
347 currentAG = chainDefList[stepPlacement].alignmentGroups[0]
348 ag_step_index = step_index+1
352 if currentAG == previousAG:
353 ag_step_index = prev_ag_step_index + 1
354 prev_ag_step_index = ag_step_index
357 previousAG = currentAG
358 prev_ag_step_index = 1
362 seqNames = [
getEmptySeqName(emptyChainDicts[iSeq][
'signature'], ag_step_index, currentAG,iSeq)
for iSeq
in range(nLegs)]
364 log.verbose(
"[serial_zip] step name for this leg: %s", seqStepName)
365 log.verbose(
"[serial_zip] created empty sequence(s): %s", seqNames)
366 log.verbose(
"[serial_zip] L1decisions %s ", chainDefList[stepPlacement2].L1decisions)
368 emptySequences =
build_empty_sequences(emptyChainDicts, step_mult,
'serial_zip', chainDefList[stepPlacement2].L1decisions, seqNames, chainName)
370 stepList[stepPlacement2] = ChainStep( seqStepName, SequenceGens = emptySequences,
371 chainDicts = emptyChainDicts)
373 newsteps.append(stepList)
374 log.debug(
'After serial_zip')
376 log.debug(
', '.
join(map(str, [step.name
for step
in s]) ) )
387 log.debug(
'[mergeSerial] Merge chainDefList:')
388 log.debug(chainDefList)
389 log.debug(
'[mergeSerial] wth ordering %s:',chainDefListOrdering)
391 for ic,cOrder
in enumerate(chainDefListOrdering):
394 cConfig = chainDefList[chainDefListOrdering.index(ic)]
395 leg_order = chainDefListOrdering.index(ic)
398 chainName = cConfig.name
399 elif chainName != cConfig.name:
400 log.error(
"[mergeSerial] Something is wrong with the combined chain name: cConfig.name = %s while chainName = %s", cConfig.name, chainName)
401 raise Exception(
"[mergeSerial] Cannot merge this chain, exiting.")
404 allSteps.append(cConfig.steps)
405 legOrdering.append(leg_order)
406 nSteps.extend(cConfig.nSteps)
407 l1Decisions.extend(chainDefList[ic].L1decisions)
408 alignmentGroups.extend(cConfig.alignmentGroups)
410 serialSteps =
serial_zip(allSteps, chainName, chainDefList, legOrdering)
412 for chain_index
in range(len(chainDefList)):
413 log.debug(
'[mergeSerial] Chain object to merge (i.e. chainDef) %s', chainDefList[chain_index])
414 for step_index, steps
in enumerate(serialSteps):
415 mySteps =
list(steps)
417 combChainSteps.append(combStep)
419 combinedChainDef = Chain(chainName, ChainSteps=combChainSteps, L1decisions=l1Decisions,
420 nSteps = nSteps, alignmentGroups = alignmentGroups)
422 log.debug(
"[mergeSerial] Serial merged chain %s with number of steps/leg %s with these steps:", chainName, combinedChainDef.nSteps)
423 for step
in combinedChainDef.steps:
424 log.debug(
' %s', step)
426 return combinedChainDef
430 return True if any step contains a real Sequence
432 for step
in parallel_steps:
433 if step
is None or step.isEmpty:
435 for seq
in step.sequenceGens:
440 def makeCombinedStep(parallel_steps, stepNumber, chainDefList, allSteps = None, currentChainSteps = None, leg_numbering = None, alignment_group = ""):
442 if allSteps
is None: allSteps = []
443 if currentChainSteps
is None: currentChainSteps = []
444 if leg_numbering
is None: leg_numbering =[]
448 log.debug(
"[makeCombinedStep] stepNumber %d, alignment_group %s, %d steps: [%s], %d chain list: [%s], alignment groups: [%s]", stepNumber, alignment_group, len(parallel_steps),
', '.
join([step.name
if step
is not None else "EMPTY" for step
in parallel_steps ]), len(chainDefList),
', '.
join([chain.name
for chain
in chainDefList]),
', '.
join([chain.alignmentGroups[0]
for chain
in chainDefList]))
460 log.debug(
"hasNonEmptyStep %d", hasNonEmptyStep)
462 if not hasNonEmptyStep:
464 if len(parallel_steps)>=len(chainDefList)
and all(step
is None for step
in parallel_steps[len(chainDefList):]):
468 parallel_steps=parallel_steps[:len(chainDefList)]
469 log.debug(
"[makeCombinedStep] removing empty steps exceeding chainDefList size. The new steps are now %s ", parallel_steps)
471 for chain_index, step
in enumerate(parallel_steps):
473 if step
is None or step.isEmpty:
474 new_stepDicts = deepcopy(chainDefList[chain_index].steps[-1].stepDicts)
475 nLegs = chainDefList[chain_index].steps[-1].nLegs
476 currentStepName =
getMergedEmptyStepName(chainDefList[chain_index].alignmentGroups[0], stepNumber, nLegs, new_stepDicts[0][
'signature'])
477 log.debug(
'[makeCombinedStep] step has no sequences, making empty step %s', currentStepName)
480 for new_stepDict
in new_stepDicts:
481 oldLegName = new_stepDict[
'chainName']
482 if re.search(
'^leg[0-9]{3}_',oldLegName):
483 oldLegName = oldLegName[7:]
484 new_stepDict[
'chainName'] =
legName(oldLegName,leg_counter)
485 log.debug(
"[makeCombinedStep] stepDict naming old: %s, new: %s", oldLegName, new_stepDict[
'chainName'])
486 stepDicts.append(new_stepDict)
491 currentStepName = step.name
494 if currentStepName.startswith(
'merged_'):
495 currentStepName = currentStepName[7:]
498 log.debug(
'[makeCombinedStep] adding step dictionaries %s',step.stepDicts)
500 for new_stepDict
in deepcopy(step.stepDicts):
501 oldLegName = new_stepDict[
'chainName']
502 if re.search(
'^leg[0-9]{3}_',oldLegName):
503 oldLegName = oldLegName[7:]
504 if len(leg_numbering) > 0:
505 leg_counter = leg_numbering[chain_index]
506 new_stepDict[
'chainName'] =
legName(oldLegName,leg_counter)
507 log.debug(
"[makeCombinedStep] stepDict naming old: %s, new: %s", oldLegName, new_stepDict[
'chainName'])
508 stepDicts.append(new_stepDict)
511 stepName +=
'_' + currentStepName
513 theChainStep = ChainStep(stepName, chainDicts = stepDicts, isEmpty =
True)
514 log.debug(
"[makeCombinedStep] Merged empty step: \n %s", theChainStep)
523 for num, chain
in enumerate(chainDefList):
524 alignLegsInStep.append(len(chain.alignmentGroups))
525 assert(len(alignLegsInStep) == len(parallel_steps))
527 for chain_index, step
in enumerate(parallel_steps):
529 if step
is None or (hasNonEmptyStep
and step.isEmpty):
533 log.debug(
"[makeCombinedStep] step %s is Empty and has %d alignemnt group legs", step.name
if step
is not None else "None", alignLegsInStep[chain_index])
534 if alignment_group ==
"":
535 alignment_group = chainDefList[0].alignmentGroups[0]
538 for innerLeg
in range(alignLegsInStep[chain_index]):
539 new_stepDict = deepcopy(chainDefList[chain_index].steps[-1].stepDicts[-1])
540 seqName =
getEmptySeqName( new_stepDict[
'signature'], stepNumber, alignment_group, innerLeg)
541 log.debug(
"[makeCombinedStep] creating Empty sequence %s", seqName)
542 signature=new_stepDict[
'signature']
543 is_fs_string =
'FS' if isFullScanRoI(chainDefList[chain_index].L1decisions[0])
else ''
544 seqName=seqName+is_fs_string
545 signature=new_stepDict[
'signature']+is_fs_string
547 stepSeq.append(functools.partial(thisEmpty, flags=
None, name=seqName))
548 oldLegName = new_stepDict[
'chainName']
549 if re.search(
'^leg[0-9]{3}_',oldLegName):
550 oldLegName = oldLegName[7:]
551 new_stepDict[
'chainName'] =
legName(oldLegName,leg_counter)
552 stepDicts.append(new_stepDict)
555 nLegs = alignLegsInStep[chain_index]
558 log.debug(
"[makeCombinedStep] found empty step to be merged, step number: %d chain_index: %s, step name: %s, made new empty sequence name: %s", stepNumber, chain_index, currentStepName, seqName)
563 log.debug(
"[makeCombinedStep] step %s with nLegs = %s", step.name,
str(step.nLegs))
564 if len(step.sequenceGens):
565 log.debug(
"[makeCombinedStep] with sequences = %s",
' '.
join(map(str, [seq.func.__name__
for seq
in step.sequenceGens])))
568 if len(step.sequenceGens) > 1:
569 log.debug(
"[makeCombinedStep] combining in an already combined chain")
571 if ( comboHypo
is None or
572 (hasattr(step.comboHypoCfg,
'__name__')
and step.comboHypoCfg.__name__ !=
"ComboHypoCfg") ):
573 comboHypo = step.comboHypoCfg
574 currentStepName = step.name
576 if currentStepName.startswith(
'merged_'):
577 currentStepName = currentStepName[7:]
578 stepSeq.extend(step.sequenceGens)
579 comboHypoTools.extend(step.comboToolConfs)
581 log.debug(
'[makeCombinedStep] adding step dictionaries %s',step.stepDicts)
582 log.debug(
'[makeCombinedStep] my leg_numbering is: %s, for chain_index %s',leg_numbering, chain_index)
583 for new_stepDict
in deepcopy(step.stepDicts):
584 oldLegName = new_stepDict[
'chainName']
585 if re.search(
'^leg[0-9]{3}_',oldLegName):
586 oldLegName = oldLegName[7:]
587 if len(leg_numbering) > 0:
588 leg_counter = leg_numbering[chain_index]
589 new_stepDict[
'chainName'] =
legName(oldLegName,leg_counter)
590 log.debug(
"[makeCombinedStep] stepDict naming old: %s, new: %s", oldLegName, new_stepDict[
'chainName'])
591 stepDicts.append(new_stepDict)
596 stepName +=
'_' + currentStepName
597 log.debug(
'[makeCombinedStep] current step name %s, with %d sequences',stepName, len(stepSeq))
600 comboHypoTools =
list(
set(comboHypoTools))
601 theChainStep = ChainStep(stepName, SequenceGens = stepSeq, chainDicts = stepDicts,
602 comboHypoCfg = comboHypo, comboToolConfs = comboHypoTools)
603 log.debug(
"[makeCombinedStep] Merged step index %d: \n %s", stepNumber, theChainStep)
611 iterators = [
iter(it)
for it
in AllSteps]
613 if len(iterators)==0:
617 for i, it
in enumerate(iterators):
620 except StopIteration:
621 if i
not in inactives:
624 if len(inactives)>=len(iterators):
627 iterators[i] = repeat(fillvalue,
int(multiplicity[i]))
630 if int(multiplicity[i]) > 1
and value == fillvalue:
631 values.extend([fillvalue]*
int(multiplicity[i]-1))
639 for ileg
in range(len(L1decisions)):
640 is_fs_string =
'FS' if isFullScanRoI(L1decisions[ileg])
else ''
641 sname = seqNames[ileg]+is_fs_string
642 log.debug(
"[%s] adding %s empty sequenc with name %s", caller, is_fs_string, sname)
645 emptySequences += [functools.partial(thisEmpty, flags=
None, name=sname)]
648 log.verbose(
"[%s] emptyChainDicts %s", caller, emptyChainDicts)
649 log.debug(
"[%s] %s has number of empty sequences %d and empty legs in stepDicts %d",
650 caller, chainName, len(emptySequences), len(emptyChainDicts))
651 if len(emptySequences) != len(emptyChainDicts):
652 log.error(
"[%s] %s has a different number of empty sequences/legs %d than stepDicts %d",
653 caller, chainName, len(emptySequences), len(emptyChainDicts))
655 raise Exception(f
"[{caller}] Cannot create this chain step, exiting.")
657 for sd
in emptyChainDicts:
658 if sd[
'signature'] ==
'Jet' or sd[
'signature'] ==
'Bjet':
660 elif len(sd[
'chainParts']) != 1:
661 log.error(
"[%s] %s has chainParts has length != 1 within a leg! chain dictionary for this step: \n %s",
662 caller, chainName, sd)
663 raise Exception(f
"[{caller}] Cannot create this chain step, exiting.")
665 step_mult += [
int(sd[
'chainParts'][0][
'multiplicity'])]
667 if len(emptySequences) != len(step_mult):
668 log.error(
"[%s] %s has a different number of empty sequences/legs %d than multiplicities %d",
669 caller, chainName, len(emptySequences), len(step_mult))
670 raise Exception(f
"[{caller}] Cannot create this chain step, exiting.")
672 log.verbose(
'[%s] step multiplicity %s',caller, step_mult)
675 return emptySequences