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])
180 seqNames = [
getEmptySeqName(previous_step_dicts[iSeq][
'signature'], current_leg_ag_length+i, align_grp_to_lengthen,i)
for iSeq
in range(len(sigNames))]
182 emptySequences =
build_empty_sequences(previous_step_dicts, step_mult,
'mergeParallel', cConfig.L1decisions, seqNames, chainName)
184 cConfig.steps.insert(current_leg_ag_length + i - 1,
185 ChainStep( seqStepName, SequenceGens = emptySequences,
186 chainDicts = previous_step_dicts)
191 perSig_lengthOfChainConfigs[iConfig][0][index_modified_leg] = max_length
193 log.debug(
"[mergeParallel] Alignment groups are empty for this combined chain")
195 allSteps.append(cConfig.steps)
197 allStepsMult.append(1)
198 nSteps.append(len(cConfig.steps))
199 l1Decisions.extend(cConfig.L1decisions)
204 if perSig_lengthOfChainConfigs
is not None and len(perSig_lengthOfChainConfigs) > 0:
205 in_chain_ag_lengths = {}
206 ag_ordering = getAlignmentGroupOrdering()
208 for ag
in ag_ordering:
209 for ag_lengths, sig_ags
in perSig_lengthOfChainConfigs:
210 for ag_length, sig_ag
in zip(ag_lengths, sig_ags):
211 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:
212 in_chain_ag_lengths[sig_ag] = ag_length
213 for ag, ag_length
in in_chain_ag_lengths.items():
214 vertical_alignment_groups += [ag]*ag_length
217 vertical_alignment_groups = [alignmentGroups[0]]*len(orderedSteps)
220 log.debug(
"[mergeParallel] alignment groups horizontal: %s", alignmentGroups)
221 log.debug(
"[mergeParallel] alignment groups vertical: %s", vertical_alignment_groups)
224 log.debug(
"[mergeParallel] len(orderedSteps): %d", len(orderedSteps))
225 for chain_index
in range(len(chainDefList)):
226 log.debug(
'[mergeParallel] Chain object to merge (i.e. chainDef) %s', chainDefList[chain_index])
228 for step_index, (steps, step_ag)
in enumerate(zip(orderedSteps,vertical_alignment_groups)):
229 mySteps =
list(steps)
230 log.debug(f
"[mergeParallel] Merging step {step_index+1} with alignment group = {step_ag}")
232 combStep =
makeCombinedStep(mySteps, step_index+1, chainDefList, orderedSteps, combChainSteps, leg_numbering, step_ag)
233 combChainSteps.append(combStep)
236 combinedChainDef = Chain(chainName, ChainSteps=combChainSteps, L1decisions=l1Decisions,
237 nSteps = nSteps, alignmentGroups = alignmentGroups)
239 log.debug(
"[mergeParallel] Parallel merged chain %s with these steps:", chainName)
240 for step
in combinedChainDef.steps:
241 log.debug(
'\n %s', step)
243 return combinedChainDef, perSig_lengthOfChainConfigs
246 currentStepName =
'Empty' + alignmentGroup +
'Align'+
str(stepNumber)+
'_'+
str(multiplicity) + signature
247 return currentStepName
251 seqName =
'Empty'+ alignGroup +
'Seq'+
str(step_number)+
'_'+
str(order) + signature
256 fsRoIList = [
'HLTNav_L1FSNOSEED',
'HLTNav_L1MET',
'HLTNav_L1J']
257 if inputL1Nav
in fsRoIList:
265 for iseq,seq
in enumerate(chainStep.sequenceGens):
273 if len(
set(cp[
'alignmentGroup']
for cp
in chainStep.stepDicts[iseq][
'chainParts'])) > 1:
274 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'])
275 raise Exception(
"[getCurrentAG] Not sure what is happening here, but I don't know what to do.")
276 filled_seq_ag += [chainStep.stepDicts[iseq][
'chainParts'][0][
'alignmentGroup']]
278 if len(filled_seq_ag) == 0:
279 log.error(
"[getCurrentAG] No non-empty sequences were found in %s", chainStep.sequenceGens)
280 log.error(
"[getCurrentAG] The chainstep is %s", chainStep)
281 raise Exception(
"[getCurrentAG] Cannot find the current alignment group for this chain")
282 elif len(
set(filled_seq_ag)) > 1:
283 log.error(
"[getCurrentAG] Found more than one alignment group for this step %s", filled_seq_ag)
284 raise Exception(
"[getCurrentAG] Cannot find the current alignment group for this chain")
286 return filled_seq_ag[0]
288 def serial_zip(allSteps, chainName, chainDefList, legOrdering):
294 legs_per_part = [len(chainDefList[stepPlacement].steps[0].multiplicity)
for stepPlacement
in legOrdering]
295 n_parts = len(allSteps)
296 log.debug(
'[serial_zip] configuring chain with %d parts with multiplicities %s', n_parts, legs_per_part)
297 log.debug(
'[serial_zip] and leg ordering %s', legOrdering)
304 for chain_index, (chainSteps, stepPlacement)
in enumerate(zip(allSteps, legOrdering)):
306 for step_index, step
in enumerate(chainSteps):
308 prev_ag_step_index = step_index
310 log.debug(
'[serial_zip] chain_index: %s step_index: %s, alignment group: %s', chain_index, step_index+1, previousAG)
312 stepList = [
None]*n_parts
315 stepList[stepPlacement] = step
316 log.debug(
'[serial_zip] Put step: %s', step.name)
319 for chain_index2, (nLegs, stepPlacement2)
in enumerate(zip(legs_per_part, legOrdering)):
320 emptyStep = stepList[stepPlacement2]
321 if emptyStep
is None:
322 if chain_index2 == chain_index:
323 log.error(
"chain_index2 = chain_index, but the stepList still has none!")
324 raise Exception(
"[serial_zip] duplicating existing leg, why has this happened??")
329 if chain_index2 < chain_index:
330 emptyChainDicts = allSteps[chain_index2][-1].stepDicts
332 emptyChainDicts = allSteps[chain_index2][0].stepDicts
334 log.debug(
"[serial_zip] nLegs: %s, len(emptyChainDicts): %s, len(L1decisions): %s", nLegs, len(emptyChainDicts), len(chainDefList[stepPlacement2].L1decisions))
336 for ileg,(emptyChainDict,_)
in enumerate(zip(emptyChainDicts,chainDefList[stepPlacement2].L1decisions)):
337 is_fs_string =
'FS' if isFullScanRoI(chainDefList[stepPlacement2].L1decisions[ileg])
else ''
338 sigNames +=[emptyChainDict[
'chainParts'][0][
'signature']+is_fs_string]
341 seqMultName =
'_'.
join([sigName
for sigName
in sigNames])
345 if len(
set(chainDefList[stepPlacement].alignmentGroups)) == 1:
346 currentAG = chainDefList[stepPlacement].alignmentGroups[0]
347 ag_step_index = step_index+1
351 if currentAG == previousAG:
352 ag_step_index = prev_ag_step_index + 1
353 prev_ag_step_index = ag_step_index
356 previousAG = currentAG
357 prev_ag_step_index = 1
361 seqNames = [
getEmptySeqName(emptyChainDicts[iSeq][
'signature'], ag_step_index, currentAG,iSeq)
for iSeq
in range(nLegs)]
363 log.verbose(
"[serial_zip] step name for this leg: %s", seqStepName)
364 log.verbose(
"[serial_zip] created empty sequence(s): %s", seqNames)
365 log.verbose(
"[serial_zip] L1decisions %s ", chainDefList[stepPlacement2].L1decisions)
367 emptySequences =
build_empty_sequences(emptyChainDicts, step_mult,
'serial_zip', chainDefList[stepPlacement2].L1decisions, seqNames, chainName)
369 stepList[stepPlacement2] = ChainStep( seqStepName, SequenceGens = emptySequences,
370 chainDicts = emptyChainDicts)
372 newsteps.append(stepList)
373 log.debug(
'After serial_zip')
375 log.debug(
', '.
join(map(str, [step.name
for step
in s]) ) )
386 log.debug(
'[mergeSerial] Merge chainDefList:')
387 log.debug(chainDefList)
388 log.debug(
'[mergeSerial] wth ordering %s:',chainDefListOrdering)
390 for ic,cOrder
in enumerate(chainDefListOrdering):
393 cConfig = chainDefList[chainDefListOrdering.index(ic)]
394 leg_order = chainDefListOrdering.index(ic)
397 chainName = cConfig.name
398 elif chainName != cConfig.name:
399 log.error(
"[mergeSerial] Something is wrong with the combined chain name: cConfig.name = %s while chainName = %s", cConfig.name, chainName)
400 raise Exception(
"[mergeSerial] Cannot merge this chain, exiting.")
403 allSteps.append(cConfig.steps)
404 legOrdering.append(leg_order)
405 nSteps.extend(cConfig.nSteps)
406 l1Decisions.extend(chainDefList[ic].L1decisions)
407 alignmentGroups.extend(cConfig.alignmentGroups)
409 serialSteps =
serial_zip(allSteps, chainName, chainDefList, legOrdering)
411 for chain_index
in range(len(chainDefList)):
412 log.debug(
'[mergeSerial] Chain object to merge (i.e. chainDef) %s', chainDefList[chain_index])
413 for step_index, steps
in enumerate(serialSteps):
414 mySteps =
list(steps)
416 combChainSteps.append(combStep)
418 combinedChainDef = Chain(chainName, ChainSteps=combChainSteps, L1decisions=l1Decisions,
419 nSteps = nSteps, alignmentGroups = alignmentGroups)
421 log.debug(
"[mergeSerial] Serial merged chain %s with number of steps/leg %s with these steps:", chainName, combinedChainDef.nSteps)
422 for step
in combinedChainDef.steps:
423 log.debug(
' %s', step)
425 return combinedChainDef
429 return True if any step contains a real Sequence
431 for step
in parallel_steps:
432 if step
is None or step.isEmpty:
434 for seq
in step.sequenceGens:
439 def makeCombinedStep(parallel_steps, stepNumber, chainDefList, allSteps = None, currentChainSteps = None, leg_numbering = None, alignment_group = ""):
441 if allSteps
is None: allSteps = []
442 if currentChainSteps
is None: currentChainSteps = []
443 if leg_numbering
is None: leg_numbering =[]
447 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]))
459 log.debug(
"hasNonEmptyStep %d", hasNonEmptyStep)
461 if not hasNonEmptyStep:
463 if len(parallel_steps)>=len(chainDefList)
and all(step
is None for step
in parallel_steps[len(chainDefList):]):
467 parallel_steps=parallel_steps[:len(chainDefList)]
468 log.debug(
"[makeCombinedStep] removing empty steps exceeding chainDefList size. The new steps are now %s ", parallel_steps)
470 for chain_index, step
in enumerate(parallel_steps):
472 if step
is None or step.isEmpty:
473 new_stepDicts = deepcopy(chainDefList[chain_index].steps[-1].stepDicts)
474 nLegs = len(chainDefList[chain_index].steps[-1].multiplicity)
475 currentStepName =
getMergedEmptyStepName(chainDefList[chain_index].alignmentGroups[0], stepNumber, nLegs, new_stepDicts[0][
'signature'])
476 log.debug(
'[makeCombinedStep] step has no sequences, making empty step %s', currentStepName)
479 for new_stepDict
in new_stepDicts:
480 oldLegName = new_stepDict[
'chainName']
481 if re.search(
'^leg[0-9]{3}_',oldLegName):
482 oldLegName = oldLegName[7:]
483 new_stepDict[
'chainName'] =
legName(oldLegName,leg_counter)
484 log.debug(
"[makeCombinedStep] stepDict naming old: %s, new: %s", oldLegName, new_stepDict[
'chainName'])
485 stepDicts.append(new_stepDict)
490 currentStepName = step.name
493 if currentStepName.startswith(
'merged_'):
494 currentStepName = currentStepName[7:]
497 log.debug(
'[makeCombinedStep] adding step dictionaries %s',step.stepDicts)
499 for new_stepDict
in deepcopy(step.stepDicts):
500 oldLegName = new_stepDict[
'chainName']
501 if re.search(
'^leg[0-9]{3}_',oldLegName):
502 oldLegName = oldLegName[7:]
503 if len(leg_numbering) > 0:
504 leg_counter = leg_numbering[chain_index]
505 new_stepDict[
'chainName'] =
legName(oldLegName,leg_counter)
506 log.debug(
"[makeCombinedStep] stepDict naming old: %s, new: %s", oldLegName, new_stepDict[
'chainName'])
507 stepDicts.append(new_stepDict)
510 stepName +=
'_' + currentStepName
512 theChainStep = ChainStep(stepName, chainDicts = stepDicts, isEmpty =
True)
513 log.debug(
"[makeCombinedStep] Merged empty step: \n %s", theChainStep)
522 for num, chain
in enumerate(chainDefList):
523 legsInStep.append(len(chain.alignmentGroups))
524 assert(len(legsInStep) == len(parallel_steps))
526 for chain_index, step
in enumerate(parallel_steps):
528 if step
is None or (hasNonEmptyStep
and step.isEmpty):
532 log.debug(
"[makeCombinedStep] step %s is Empty and has %d legs", step.name
if step
is not None else "None", legsInStep[chain_index])
533 if alignment_group ==
"":
534 alignment_group = chainDefList[0].alignmentGroups[0]
537 for innerLeg
in range(legsInStep[chain_index]):
538 new_stepDict = deepcopy(chainDefList[chain_index].steps[-1].stepDicts[-1])
539 seqName =
getEmptySeqName( new_stepDict[
'signature'], stepNumber, alignment_group, innerLeg)
540 log.debug(
"[makeCombinedStep] creating Empty sequence %s", seqName)
541 signature=new_stepDict[
'signature']
542 is_fs_string =
'FS' if isFullScanRoI(chainDefList[chain_index].L1decisions[0])
else ''
543 seqName=seqName+is_fs_string
544 signature=new_stepDict[
'signature']+is_fs_string
546 stepSeq.append(functools.partial(thisEmpty, name=seqName))
547 oldLegName = new_stepDict[
'chainName']
548 if re.search(
'^leg[0-9]{3}_',oldLegName):
549 oldLegName = oldLegName[7:]
550 new_stepDict[
'chainName'] =
legName(oldLegName,leg_counter)
551 stepDicts.append(new_stepDict)
554 nLegs = legsInStep[chain_index]
557 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)
562 log.debug(
"[makeCombinedStep] step %s, multiplicity = %s", step.name,
str(step.multiplicity))
563 if len(step.sequenceGens):
564 log.debug(
"[makeCombinedStep] with sequences = %s",
' '.
join(map(str, [seq.func.__name__
for seq
in step.sequenceGens])))
567 if len(step.sequenceGens) > 1:
568 log.debug(
"[makeCombinedStep] combining in an already combined chain")
570 if ( comboHypo
is None or
571 (hasattr(step.comboHypoCfg,
'__name__')
and step.comboHypoCfg.__name__ !=
"ComboHypoCfg") ):
572 comboHypo = step.comboHypoCfg
573 currentStepName = step.name
575 if currentStepName.startswith(
'merged_'):
576 currentStepName = currentStepName[7:]
577 stepSeq.extend(step.sequenceGens)
578 comboHypoTools.extend(step.comboToolConfs)
580 log.debug(
'[makeCombinedStep] adding step dictionaries %s',step.stepDicts)
581 log.debug(
'[makeCombinedStep] my leg_numbering is: %s, for chain_index %s',leg_numbering, chain_index)
582 for new_stepDict
in deepcopy(step.stepDicts):
583 oldLegName = new_stepDict[
'chainName']
584 if re.search(
'^leg[0-9]{3}_',oldLegName):
585 oldLegName = oldLegName[7:]
586 if len(leg_numbering) > 0:
587 leg_counter = leg_numbering[chain_index]
588 new_stepDict[
'chainName'] =
legName(oldLegName,leg_counter)
589 log.debug(
"[makeCombinedStep] stepDict naming old: %s, new: %s", oldLegName, new_stepDict[
'chainName'])
590 stepDicts.append(new_stepDict)
595 stepName +=
'_' + currentStepName
596 log.debug(
'[makeCombinedStep] current step name %s, with %d sequences',stepName, len(stepSeq))
599 comboHypoTools =
list(
set(comboHypoTools))
600 theChainStep = ChainStep(stepName, SequenceGens = stepSeq, chainDicts = stepDicts,
601 comboHypoCfg = comboHypo, comboToolConfs = comboHypoTools)
602 log.debug(
"[makeCombinedStep] Merged step index %d: \n %s", stepNumber, theChainStep)
610 iterators = [iter(it)
for it
in AllSteps]
612 if len(iterators)==0:
616 for i, it
in enumerate(iterators):
619 except StopIteration:
620 if i
not in inactives:
623 if len(inactives)>=len(iterators):
626 iterators[i] = repeat(fillvalue,
int(multiplicity[i]))
629 if int(multiplicity[i]) > 1
and value == fillvalue:
630 values.extend([fillvalue]*
int(multiplicity[i]-1))
638 for ileg
in range(len(L1decisions)):
639 is_fs_string =
'FS' if isFullScanRoI(L1decisions[ileg])
else ''
640 sname = seqNames[ileg]+is_fs_string
641 log.debug(
"[%s] adding %s empty sequenc with name %s", caller, is_fs_string, sname)
643 emptySequences += [functools.partial(thisEmpty, name=sname)]
646 log.verbose(
"[%s] emptyChainDicts %s", caller, emptyChainDicts)
647 log.debug(
"[%s] %s has number of empty sequences %d and empty legs in stepDicts %d",
648 caller, chainName, len(emptySequences), len(emptyChainDicts))
649 if len(emptySequences) != len(emptyChainDicts):
650 log.error(
"[%s] %s has a different number of empty sequences/legs %d than stepDicts %d",
651 caller, chainName, len(emptySequences), len(emptyChainDicts))
653 raise Exception(f
"[{caller}] Cannot create this chain step, exiting.")
655 for sd
in emptyChainDicts:
656 if sd[
'signature'] ==
'Jet' or sd[
'signature'] ==
'Bjet':
658 elif len(sd[
'chainParts']) != 1:
659 log.error(
"[%s] %s has chainParts has length != 1 within a leg! chain dictionary for this step: \n %s",
660 caller, chainName, sd)
661 raise Exception(f
"[{caller}] Cannot create this chain step, exiting.")
663 step_mult += [
int(sd[
'chainParts'][0][
'multiplicity'])]
665 if len(emptySequences) != len(step_mult):
666 log.error(
"[%s] %s has a different number of empty sequences/legs %d than multiplicities %d",
667 caller, chainName, len(emptySequences), len(step_mult))
668 raise Exception(f
"[{caller}] Cannot create this chain step, exiting.")
670 log.verbose(
'[%s] step multiplicity %s',caller, step_mult)
673 return emptySequences