def sparseAlignReal(self, stateMachine, points): p = points["points"][:] gp = points["gapPoints"][:] blp = points["blGaps"][:] trp = points["trGaps"][:] pPA = {} for i in p: pPA[i] = 0 def join(one, two): def f(*args): two(*args) one(*args) return f total = [0] def totalGetter(t): total[0] = t pP.total(t) #totalFn, startDiagonal, endDiagonal, interval rescale = SparseAlign.Rescale(1, stateMachine.stateNo()) stateMachine.mapEmissions(rescale.rescaleFn) pPoints = p[:] pPoints.sort() pPoint = pPoints[len(pPoints)-1] bTransition = SparseAlign.BTransitionAndTotalReCalculator(totalGetter, 0, pPoint[0] + pPoint[1], r.randrange(1, 2 + 1.5*(pPoint[0] + pPoint[1])), stateMachine.stateNo()) pP = SparseAlign.PosteriorProbs(pPA, stateMachine.stateNo()) fn = stateMachine.getFns(join(pP.bTransition, bTransition.bTransition)) fn_2 = stateMachine.getFns(bTransition.bTransition) fn2 = stateMachine.getFns(SparseAlign.fTransition(stateMachine.stateNo())) x1 = [0] y1 = [0] x2 = [0] y2 = [0] def diagBuilder(i, j): x2[0] = i y2[0] = j def diagStart(i, j): x1[0] = i y1[0] = j x2[0] = i y2[0] = j def diagEnd(): pass def dFW(diagFn): def f(s1, sI, s2, sI2, ): return diagFn(s1, sI, s2, sI2, x2[0]-1, y2[0]-1, x1[0], y1[0]) return f def fn3(i): if i == MATCH: return 0 return Maths.NEG_INFINITY startStates = [ fn3(i) for i in stateMachine.getStateTypes() ] SparseAlign.sparseAlign(startStates[:],#*stateMachine.stateNo(), p, blp, trp, startStates[:],#[0]*stateMachine.stateNo(), stateMachine.stateNo(), fn2[(MATCH, GAP)], fn2[(GAP, GAP)], diagStart, diagBuilder, diagEnd, dFW(fn2[(GAP, MATCH)]), dFW(fn2[(MATCH, MATCH)]), fn_2[(MATCH, GAP)], fn_2[(GAP, GAP)], join(diagStart, pP.diagStart), join(diagBuilder, pP.diagBuilder), join(diagEnd, pP.diagEnd), dFW(fn[(GAP, MATCH)]), dFW(fn[(MATCH, MATCH)]), totalGetter, rescale, 1000000) return (total[0], total[0], pPA)
def alignScript(stateMachine, startStates, endStates, diagStart, diagBuilder, diagEnd, xStart, yStart, pointsFile, bottomLeftPointsFile, topRightPointsFile, outputFile, seqXFile, seqYFile, diagTraceBackLimit=100000, retotallingInterval=50): MATCH = SparseAlign.StateMachine.MATCH GAP = SparseAlign.StateMachine.GAP def fn(f): def fn2(i): i = i.split() return (i[0] - xStart, i[1] - yStart) return [ fn2(i) for i in open(pointsFile, 'r').readlines() ] points = fn(pointsFile) points.sort() bottomLeftPoints = fn(bottomLeftPointsFile) topRightPoints = fn(topRightPointsFile) def fn(f): return "".join([ i[:-1] for i in open("out", 'r').readlines() ]) seqX = fn(seqXFile) seqY = fn(seqYFile) pPA = {} for i in points: pPA[i] = 0 posteriorProbs = SparseAlign.PosteriorProbs(pPA, stateMachine.stateNo()) rescale = SparseAlign.Rescale(sum(points[0][0:2])+1, stateMachine.stateNo()) stateMachine.mapEmissions(rescale.rescaleFn) bTransition = SparseAlign.\ BTransitionAndTotalReCalculator(posteriorProbs.total, \ sum(points[0][0:2]), \ sum(points[-1][0:2]),\ retotallingInterval, \ stateMachine.stateNo()) backMatchFn = stateMachine.getFns(join(pP.bTransition, bTransition.bTransition)) backGapFn = stateMachine.getFns(bTransition.bTransition) forwardFn = stateMachine.getFns(SparseAlign.fTransition(stateMachine.stateNo())) def join(one, two): def f(*args): two(*args) one(*args) return f SparseAlign.\ sparseAlign(startStates, points, bottomLeftPoints, topRightPoints, endStates, stateMachine.stateNo(), forwardFn((MATCH, GAP)), forwardFn[(GAP, GAP)], diagStart, diagBuilder, diagEnd, forwardFn[(GAP, MATCH)], forwardFn[(MATCH, MATCH)], backGapFn[(MATCH, GAP)], backGapFn[(GAP, GAP)], join(diagStart, posteriorProbs.diagStart), join(diagBuilder, posteriorProbs.diagBuilder), join(diagEnd, posteriorProbs.diagEnd), forwardFn[(GAP, MATCH)], forwardFn[(MATCH, MATCH)], posteriorProbs.total, rescale, diagTraceBackLimit) out = open(outputFile, 'w') for i in pPA.keys(): out.write("%s %s %s \n" % (i[0] + xStart, i[1] + yStart, pPA[i])) out.close()