ntuplePrintersDiff Namespace Reference

Classes
class	_DiffResult
class	_IndentPrinter
class	_RecHitPrinter
class	_TrackAssociation
class	_TrackingParticleMatchPrinter
class	_TracksByHitsMatcher
class	SeedPrinter
class	TrackingParticlePrinter
class	TrackPrinter

Functions
def	_areSameTracks (trk1, trk2)
def	_associateTracksByTrackingParticlesAndHits (lst1, lst2)
def	_commonHits (trk1, trk2)
def	_difflist (list1, list2)
def	_formatHitDiffForTwiki (diffHits, prefix)
def	_hitPatternSummary (hits)
def	_makediff (list1, list2, equalPrefix=" ")
def	_mapdiff (func, obj1, obj2)
def	_matchTracksByHits (reftrk, trklist)
def	diffTrackListsFromSameTrackingParticle (trackPrinter, lst1, lst2, lst1extra=[], lst2extra=[], diffByHitsOnly=False)
def	diffTrackListsGeneric (trackPrinter, lst1, lst2, ignoreAdditionalLst2=False)

Function Documentation

def ntuplePrintersDiff._areSameTracks (   trk1,   trk2  )

private

Definition at line 177 of file ntuplePrintersDiff.py.

References _commonHits(), and diffTreeTool.index.

Referenced by diffTrackListsFromSameTrackingParticle(), and diffTrackListsGeneric().

def _areSameTracks(trk1, trk2):
    ncommon = _commonHits(trk1, trk2)

    # if tracks have same hits, consider their reco as identical
    if not (ncommon == trk1.nValid() and ncommon == trk2.nValid()):
        return False

    # although if there is any change in their iterations, mark them different
    if not (trk1.algoMask() == trk2.algoMask() and trk1.algo() == trk2.algo() and trk1.originalAlgo() == trk2.originalAlgo()):
        return False

    # if reco is the same, check if they are matched to the
    # same TPs (in case the track-TP matching is modified
    # between ntuples)
    if trk1.nMatchedTrackingParticles() != trk2.nMatchedTrackingParticles():
        return False

    for tpInfo1, tpInfo2 in itertools.izip(trk1.matchedTrackingParticleInfos(), trk2.matchedTrackingParticleInfos()):
        if tpInfo1.trackingParticle().index() != tpInfo2.trackingParticle().index():
            return False

    return True

def ntuplePrintersDiff._associateTracksByTrackingParticlesAndHits (   lst1,   lst2  )

private

Definition at line 370 of file ntuplePrintersDiff.py.

References list(), and harvestTrackValidationPlots.str.

Referenced by diffTrackListsGeneric().

def _associateTracksByTrackingParticlesAndHits(lst1, lst2):
    trks1 = list(lst1)
    trks2 = list(lst2)

    trks1Matcher = _TracksByHitsMatcher(trks1)
    trks2Matcher = _TracksByHitsMatcher(trks2)

    # Used to have exactly the same Track objects for the same index
    trks1Dict = {t.index(): t for t in trks1}
    trks2Dict = {t.index(): t for t in trks2}

    # Bit of a hack...
    tps1 = None
    tps2 = None
    if len(trks1) > 0:
        tps1 = TrackingParticles(trks1[0]._tree)
    if len(trks2) > 0:
        tps2 = TrackingParticles(trks2[0]._tree)

    trkAssoc1 = {}
    trkAssoc2 = {}

    def _getOrCreateAssoc(trk, d, **kwargs):
        if trk.index() in d:
            a = d[trk.index()]
        else:
            a = _TrackAssociation()
            d[trk.index()] = a
        a.extend(**kwargs)
        return a

    while len(trks1) > 0:
        trk1 = trks1.pop(0)
        assoc1 = _getOrCreateAssoc(trk1, trkAssoc1, trks1=[trk1])

        # First associate via TP
        if trk1.nMatchedTrackingParticles() > 0 and tps2:
            matched = False

            for tpInfo1 in trk1.matchedTrackingParticleInfos():
                tp1 = tpInfo1.trackingParticle()

                # Find possible duplicates within trks1
                for trkInfo1 in tp1.matchedTrackInfos():
                    t1 = trkInfo1.track()
                    t1Index = t1.index()
                    if t1Index != trk1.index():
                        if t1Index in trks1Dict:
                            assoc1.extend(trks1=[t1]) # trk1 -> t1
                            _getOrCreateAssoc(t1, trkAssoc1, trks1=[t1, trk1]) # t1 -> trk1
                            #print "trk1 %d <-> t1 %d (TP)" % (trk1.index(), t1.index())
                            trks1.remove(trks1Dict[t1Index])
                        else:
                            #print "trk1 %d -> t1 %d (TP, not in list)" % (trk1.index(), t1.index())
                            assoc1.extend(trks1OutsideList=[t1]) # trk1 -> t1, if t1 is not in trks1

                # Then look for the same tp in trks2
                tp2 = tps2[tp1.index()]
                for trkInfo2 in tp2.matchedTrackInfos():
                    matched = True
                    t2 = trkInfo2.track()
                    t2Index = t2.index()
                    if t2Index in trks2Dict:
                        assoc1.extend(trks2=[t2]) # trk1 -> t2
                        _getOrCreateAssoc(t2, trkAssoc2, trks1=[trk1], trks2=[t2]) # t2 -> trk1
                        #print "trk1 %d <-> t2 %d (TP)" % (trk1.index(), t2.index())
                        try:
                            trks2.remove(trks2Dict[t2Index]) # can fail if t2 has already been matched via hits
                        except ValueError:
                            pass
                    else:
                        #print "trk1 %d -> t2 %d (TP, not in list)" % (trk1.index(), t2.index())
                        assoc1.extend(trks2OutsideList=[t2]) # trk1 -> t2, if t2 is not in trks2

            if matched:
                continue

        # If no matching tracks in trks2 via TrackingParticles, then
        # proceed finding the best match via hits
        (matchedTrk2, ncommon) = trks2Matcher.match(trk1)
        if matchedTrk2 is not None and ncommon >= 3:
            assoc1.extend(trks2=[matchedTrk2])
            assoc2 = _getOrCreateAssoc(matchedTrk2, trkAssoc2, trks1=[trk1], trks2=[matchedTrk2])
            #print "trk1 %d <-> t2 %d (hits)" % (trk1.index(), matchedTrk2.index())
            try:
                trks2.remove(matchedTrk2) # can fail if matchedTrk2 has already been matched via TP
            except ValueError:
                pass

            (matchedTrk1, ncommon1) = trks1Matcher.match(matchedTrk2)
            # if matchedTrk1 has TP, the link from matchedTrk1 -> matchedTrk2 will be created later
            if (matchedTrk1.nMatchedTrackingParticles() == 0 or not tps2) and matchedTrk1.index() != trk1.index():
                assoc2.extend(trks1=[matchedTrk1])
                _getOrCreateAssoc(matchedTrk1, trkAssoc1, trks1=[matchedTrk1], trks2=[matchedTrk2])
                #print "trk1 %d <-> t2 %d (hits, via t2)" % (matchedTrk1.index(), matchedTrk2.index())

        # no match

    # remaining tracks in trks2
    for trk2 in trks2:
        assoc2 = _getOrCreateAssoc(trk2, trkAssoc2, trks2=[trk2])
        # collect duplicates
        if trk2.nMatchedTrackingParticles() > 0:
            for tpInfo2 in trk2.matchedTrackingParticleInfos():
                tp2 = tpInfo2.trackingParticle()
                for trkInfo2 in tp2.matchedTrackInfos():
                    t2 = trkInfo2.track()
                    t2Index = t2.index()
                    if t2Index in trks2Dict:
                        assoc2.extend(trks2=[t2])
                        #print "trk2 %d -> t2 %d (TP)" % (trk2.index(), t2.index())
                    else:
                        assoc2.extend(trks2OutsideList=[t2])
                        #print "trk2 %d -> t2 %d (TP, not in list)" % (trk2.index(), t2.index())

    # merge results
    # any good way to avoid copy-past?
    for ind, assoc in trkAssoc1.iteritems():
        for t1 in assoc.trks1():
            a = trkAssoc1[t1.index()]
            assoc.merge(a)
            a.merge(assoc)
        for t2 in assoc.trks2():
            a = trkAssoc2[t2.index()]
            assoc.merge(a)
            a.merge(assoc)
    for ind, assoc in trkAssoc2.iteritems():
        for t2 in assoc.trks2():
            a = trkAssoc2[t2.index()]
            assoc.merge(a)
            a.merge(assoc)
        for t1 in assoc.trks1():
            a = trkAssoc1[t1.index()]
            assoc.merge(a)
            a.merge(assoc)

    for ind, assoc in itertools.chain(trkAssoc1.iteritems(), trkAssoc2.iteritems()):
        #if ind in [437, 1101]:
        #    print "----"
        #    print ind, [t.index() for t in assoc.trks1()], [t.index() for t in assoc.trks2()]
        for t1 in assoc.trks1():
            a = trkAssoc1[t1.index()]
            assoc.merge(a)
            a.merge(assoc)

        #if ind in [437, 1101]:
        #    print ind, [t.index() for t in assoc.trks1()], [t.index() for t in assoc.trks2()]

        for t2 in assoc.trks2():
            a = trkAssoc2[t2.index()]
            assoc.merge(a)
            a.merge(assoc)
        #if ind in [437, 1101]:
        #    print ind, [t.index() for t in assoc.trks1()], [t.index() for t in assoc.trks2()]
        #    print "####"

    # collapse to a single collection of associations
    allAssocs = []
    while len(trkAssoc1) > 0:
        (t1Index, assoc) = trkAssoc1.popitem()

        #if t1Index == 1299:
        #    print t1Index, [t.index() for t in assoc.trks2()]
        for t1 in assoc.trks1():
            if t1.index() == t1Index: continue
            trkAssoc1.pop(t1.index())
        for t2 in assoc.trks2():
            trkAssoc2.pop(t2.index())
        allAssocs.append(assoc)
    while len(trkAssoc2) > 0:
        (t2Index, assoc) = trkAssoc2.popitem()
        if len(assoc.trks1()) > 0:
            raise Exception("len(assoc.trks1()) %d != 0 !!! %s for t2 %d" % (len(assoc.trks1()), str([t.index() for t in assoc.trks1()]), t2Index))
        for t2 in assoc.trks2():
            if t2.index() == t2Index: continue
            trkAssoc2.pop(t2.index())
        allAssocs.append(assoc)

    return allAssocs

def ntuplePrintersDiff._commonHits (   trk1,   trk2  )

private

Returns the number of common hits in trk1 and trk2. Matching is
done via the hit type and index, so effectively the matching is
done by clusters. Invalid hits are ignored.

Definition at line 13 of file ntuplePrintersDiff.py.

Referenced by _areSameTracks(), and diffTrackListsGeneric().

def _commonHits(trk1, trk2):
    """Returns the number of common hits in trk1 and trk2. Matching is
    done via the hit type and index, so effectively the matching is
    done by clusters. Invalid hits are ignored.

    """
    hits1 = set()
    for hit in trk1.hits():
        if not hit.isValidHit(): continue
        hits1.add( (type(hit), hit.index()) )

    ncommon = 0
    for hit in trk2.hits():
        if not hit.isValidHit(): continue
        if (type(hit), hit.index()) in hits1:
            ncommon += 1

    return ncommon

def ntuplePrintersDiff._difflist (   list1,   list2  )

private

Definition at line 158 of file ntuplePrintersDiff.py.

References list().

Referenced by _makediff().

def _difflist(list1, list2):
    diff = difflib.unified_diff(list1, list2, lineterm="", n=len(list1))
    for item in diff:
        if item[:2] == "@@":
            break
    return list(diff)

def ntuplePrintersDiff._formatHitDiffForTwiki (   diffHits,   prefix  )

private

Definition at line 618 of file ntuplePrintersDiff.py.

References join().

Referenced by ntuplePrintersDiff.SeedPrinter.diff(), and ntuplePrintersDiff.TrackPrinter.diff().

def _formatHitDiffForTwiki(diffHits, prefix):
    line_re = re.compile("(?P<sign>[ \-+])\s+(?P<det>[a-zA-Z]+)(?P<lay>\d+)\D*?(\((?P<missing>missing|inactive)\))?\s+\d+")

    summary = []
    prevdet = ""
    prevsign = " "
    diffLines = diffHits.lines()

    # skip anything before the first line with "hits"
    for line in diffLines:
        if "hits" in line:
            break

    header = True
    for line in diffLines:
        # skip multiple occurrances of "hits" line, but only until
        # first line without "hits" is encountered
        if header:
            if "hits" in line:
                continue
            else:
                header = False

        m = line_re.search(line)
        if not m:
            break
            raise Exception("regex not found from line %s" % line.rstrip())
        sign = m.group("sign")
        det = m.group("det")
        lay = m.group("lay")

        if det != prevdet:
            if prevsign != " ":
                summary.append("%ENDCOLOR%")
                prevsign = " "
            summary.extend([" ", det])
            prevdet = det

        if sign != prevsign:
            if prevsign != " ":
                summary.append("%ENDCOLOR%")
            if sign == "-":
                summary.append("%RED%")
            elif sign == "+":
                summary.append("%GREEN%")
            prevsign = sign

        #print sign, det, lay
        #if len(summary) > 0:
        #    print " ", summary[-1]

        #if det != prevdet:
        #    if prevsign != " ":
        #        #if len(summary) > 0:
        #        #    if 
        #        summary.append("%ENDCOLOR")
        #    summary.extend([" ", det])
        #    if prevsign == "-":
        #        summary.append("%RED%")
        #    elif prevsign == "+":
        #        summary.append("%GREEN%")
        #    prevdet = det
        summary.append(lay)
        if m.group("missing"):
            if m.group("missing") == "missing":
                summary.append("(m)")
            elif m.group("missing") == "inactive":
                summary.append("(i)")

    if prevsign != " ":
        summary.append("%ENDCOLOR%")
    # prune "changed" missing/inactive hits
    i = 2
    while i < len(summary)-5:
        if summary[i] == "(i)" or summary[i] == "(m)":
            if summary[i-2] == "%RED%" and summary[i+1] == "%ENDCOLOR%" and summary[i+2] == "%GREEN%" and summary[i+3] == summary[i-1] and summary[i+4] == summary[i] and summary[i+5] == "%ENDCOLOR%":
                summary[i-2:i+6] = [summary[i-1], summary[i]]
        i += 1

    line = " "+"".join(summary)
    return ["?"+prefix+line]

# Common detailed printout helpers

def ntuplePrintersDiff._hitPatternSummary (   hits )

private

Definition at line 701 of file ntuplePrintersDiff.py.

References harvestTrackValidationPlots.str.

Referenced by ntuplePrintersDiff.SeedPrinter.printHits(), ntuplePrintersDiff.TrackPrinter.printHits(), and ntuplePrintersDiff.TrackingParticlePrinter.printHits().

def _hitPatternSummary(hits):
    summary = ""

    prevdet = 0
    for hit in hits:
        det = hit.subdet()
        lay = hit.layer()

        if det != prevdet:
            summary += " "+SubDet.toString(det)
            prevdet = det

        summary += str(lay)
        if isinstance(hit, InvalidHit):
            summary += "(%s)"%InvalidHit.Type.toString(hit.type())[0]

    return summary

def ntuplePrintersDiff._makediff (   list1,   list2,   equalPrefix = " "  )

private

Definition at line 165 of file ntuplePrintersDiff.py.

References _difflist().

Referenced by _mapdiff(), ntuplePrintersDiff.SeedPrinter.diff(), ntuplePrintersDiff.TrackPrinter.diff(), ntuplePrintersDiff.TrackingParticlePrinter.diffMatchedSeeds(), ntuplePrintersDiff.TrackingParticlePrinter.diffMatchedTracks(), and diffTrackListsFromSameTrackingParticle().

def _makediff(list1, list2, equalPrefix=" "):
    diff = _difflist(list1, list2)
    if len(diff) == 0:
        return _DiffResult([equalPrefix+s for s in list1], hasDifference=False)
    else:
        return _DiffResult(diff, hasDifference=True)

def ntuplePrintersDiff._mapdiff (   func,   obj1,   obj2  )

private

Definition at line 172 of file ntuplePrintersDiff.py.

References _makediff(), and RecoEcal_EventContent_cff.func.

Referenced by ntuplePrintersDiff.SeedPrinter.diff(), ntuplePrintersDiff.TrackPrinter.diff(), ntuplePrintersDiff.TrackingParticlePrinter.diff(), and diffTrackListsFromSameTrackingParticle().

def _mapdiff(func, obj1, obj2):
    lst1 = func(obj1) if obj1 is not None else []
    lst2 = func(obj2) if obj2 is not None else []
    return _makediff(lst1, lst2)

def ntuplePrintersDiff._matchTracksByHits (   reftrk,   trklist  )

private

Definition at line 32 of file ntuplePrintersDiff.py.

Referenced by ntuplePrintersDiff.TrackingParticlePrinter.diffMatchedSeeds(), and diffTrackListsFromSameTrackingParticle().

def _matchTracksByHits(reftrk, trklist):
    if len(trklist) == 0:
        return (None, 0)

    hits1 = set()
    for hit in reftrk.hits():
        if not hit.isValidHit(): continue
        hits1.add( (type(hit), hit.index()) )

    best = (None, 0)
    for trk in trklist:
        ncommon = 0
        for hit in trk.hits():
            if not hit.isValidHit(): continue
            if (type(hit), hit.index()) in hits1:
                ncommon += 1
        if ncommon > best[1]:
            best = (trk, ncommon)

    return best

def ntuplePrintersDiff.diffTrackListsFromSameTrackingParticle	(		trackPrinter,
			lst1,
			lst2,
			lst1extra = [],
			lst2extra = [],
			diffByHitsOnly = False
	)

lst1 and lst2 are the main lists to make the diff from.

lst1extra and lst2extra are optional to provide suplementary
tracks. Use case: lst1 and lst2 are subset of full tracks,
lst1extra and lst2extra contain tracks matched to the same
TrackingParticle but are outside of the selection of lst1/lst2.

Definition at line 200 of file ntuplePrintersDiff.py.

References _areSameTracks(), _makediff(), _mapdiff(), _matchTracksByHits(), list(), and GetRecoTauVFromDQM_MC_cff.next.

Referenced by ntuplePrintersDiff.TrackingParticlePrinter.diffMatchedTracks(), and diffTrackListsGeneric().

def diffTrackListsFromSameTrackingParticle(trackPrinter, lst1, lst2, lst1extra=[], lst2extra=[], diffByHitsOnly=False):
    """lst1 and lst2 are the main lists to make the diff from.

    lst1extra and lst2extra are optional to provide suplementary
    tracks. Use case: lst1 and lst2 are subset of full tracks,
    lst1extra and lst2extra contain tracks matched to the same
    TrackingParticle but are outside of the selection of lst1/lst2.
    """

    diff = _DiffResult()

    _trks1extra = list(lst1extra)
    _trks2extra = list(lst2extra)

    trks1 = list(lst1)+_trks1extra
    trks2 = list(lst2)+_trks2extra # make copy because it is modified

    trks1extra = set([t.index() for t in _trks1extra])
    trks2extra = set([t.index() for t in _trks2extra])

    trks1Empty = (len(trks1) == 0)
    trks2Empty = (len(trks2) == 0)

    if trks1Empty and trks2Empty:
        return diff

    # make sure all tracks really come from a single TP
    # just to simplify the work loop, generalization can be considered later
    commonTP = None
    def _findCommonTP(_lst, _commonTP, _name):
        for trk in _lst:
            if trk.nMatchedTrackingParticles() != 1:
                raise Exception("Track %d from %s is matched to %d TPs. This is not supported by this function yet." % (trk.index(), _name, trk.nMatchedTrackingParticles()))
            if _commonTP is None:
                _commonTP = next(trk.matchedTrackingParticleInfos()).trackingParticle()
            else:
                tp = next(trk.matchedTrackingParticleInfos()).trackingParticle()
                if tp.index() != _commonTP.index():
                    raise Exception("Track %d from %s is matched to TP %d, which differs from the TP %d of already processed tracks." % (trk.index(), _name, _commonTP.index(), tp.index()))
        return _commonTP
    commonTP = _findCommonTP(trks1, commonTP, "lst1")
    commonTP = _findCommonTP(trks2, commonTP, "lst2")

    # Need some tracks from trks1 and trks2 to print the TrackingParticle information
    someTrk1 = trks1[0] if not trks1Empty else None
    someTrk2 = trks2[0] if not trks2Empty else None

    for trk1 in trks1:
        (matchedTrk2, ncommon) = _matchTracksByHits(trk1, trks2)

        # no more tracks in tp2
        if matchedTrk2 is None:
            if trk1.index() in trks1extra:
                raise Exception("Track %d was found in trks1extra but matchedTrk2 is None, this should not happen" % trk1.index())
            diff.extend(_makediff(trackPrinter.printTrack(trk1), []))
        else: # diff trk1 to best-matching track from trks2
            someTrk2 = matchedTrk2
            trks2.remove(matchedTrk2)
            tmp = trackPrinter.diff(trk1, matchedTrk2, diffTrackingParticles=False)
            if diffByHitsOnly and _areSameTracks(trk1, matchedTrk2):
                tmp.setDifference(False)
            tmp.highlight(plus=(matchedTrk2.index() in trks2extra), minus=(trk1.index() in trks1extra))
            diff.extend(tmp)

    for trk2 in trks2: # remaining tracks in trks2
        if trk2.index() in trks2extra:
            raise Exception("Track %d was found in trks2extra, but without matching track in trks1, this should not happen" % trk2.index())
        diff.extend(_makediff([], trackPrinter.printTrack(trk2)))

    # finally add information of the trackingParticle
    # easiest is to pass a track matched to the TP
    tmp = _mapdiff(trackPrinter.printMatchedTrackingParticles, someTrk1, someTrk2)
    tmp.setDifference(False) # we know the TP is the same, even if the "track match" information will differ
    def _makere(lst):
        r = []
        for i in lst: r.extend([re.compile("Tracks:.*%d:"%i), re.compile("matched to tracks.*%d"%i)])
        return r
    plusre = _makere(trks2extra)
    minusre = _makere(trks1extra)
    tmp.highlightLines(plusre, minusre)
    diff.extend(tmp)

    return diff

def ntuplePrintersDiff.diffTrackListsGeneric	(		trackPrinter,
			lst1,
			lst2,
			ignoreAdditionalLst2 = False
	)

Definition at line 550 of file ntuplePrintersDiff.py.

References _areSameTracks(), _associateTracksByTrackingParticlesAndHits(), _commonHits(), diffTrackListsFromSameTrackingParticle(), list(), GetRecoTauVFromDQM_MC_cff.next, and alignCSCRings.r.

def diffTrackListsGeneric(trackPrinter, lst1, lst2, ignoreAdditionalLst2=False):
    associations = _associateTracksByTrackingParticlesAndHits(lst1, lst2)

    # sort in eta
    associations.sort(key=methodcaller("minEta"))

    diff = _DiffResult()
    for assoc in associations:
        if assoc.hasCommonTrackingParticle():
            if len(assoc.trks1()) == 0 and ignoreAdditionalLst2:
                continue

            tmp = diffTrackListsFromSameTrackingParticle(trackPrinter, assoc.trks1(), assoc.trks2(), lst1extra=assoc.trks1OutsideList(), lst2extra=assoc.trks2OutsideList(), diffByHitsOnly=True)
            if tmp.hasDifference():
                diff.extend(tmp)
                diff.extend([" "])
        elif len(assoc.trks1()) == 1 and len(assoc.trks2()) == 1:
            trk1 = assoc.trks1()[0]
            trk2 = assoc.trks2()[0]

            if not _areSameTracks(trk1, trk2):
                diff.extend(trackPrinter.diff(trk1, trk2))
                diff.extend([" "])
        elif len(assoc.trks2()) == 0:
            for t in assoc.trks1():
                diff.extend(trackPrinter.diff(t, None))
                diff.extend([" "])
        elif len(assoc.trks1()) == 0:
            if ignoreAdditionalLst2:
                continue
            for t in assoc.trks1():
                diff.extend(trackPrinter.diff(None, t))
                diff.extend([" "])
        else:
            # needs to be rather generic, let's start by sorting by the innermost hit
            trks1 = list(assoc.trks1())
            trks2 = list(assoc.trks2())
            trks1.sort(key=lambda t: next(t.hits()).r())
            trks2.sort(key=lambda t: next(t.hits()).r())

            # then calculate number of shared hits for each pair
            ncommon = []
            for i1, t1 in enumerate(trks1):
                for i2, t2 in enumerate(trks2):
                    ncommon.append( (i1, i2, _commonHits(t1, t2)) )

            # sort that by number of common hits, descending order
            ncommon.sort(key=itemgetter(2), reverse=True)

            # then make the diffs starting from the pair with largest number of common hits
            pairs = [None]*len(trks1)
            usedT2 = [False]*len(trks2)
            for i1, i2, ncom in ncommon:
                if pairs[i1] is None:
                    pairs[i1] = i2
                    usedT2[i2] = True

            for i1, i2 in enumerate(pairs):
                t1 = trks1[i1]
                t2 = trks2[i2]
                diff.extend(trackPrinter.diff(t1, t2))
            for i2, used in enumerate(usedT2):
                if not used:
                    diff.extend(trackPrinter.diff(None, trks2[i2]))
            diff.extend([" "])

    return diff