lib/pslTransMap.c File Reference

#include "common.h"
#include "pslTransMap.h"
#include "psl.h"

Include dependency graph for pslTransMap.c:

Go to the source code of this file.

Data Structures
struct	block
Functions
static void	pslProtToNA (struct psl *psl)
static void	pslNAToProt (struct psl *psl)
static struct psl *	createMappedPsl (struct psl *inPsl, struct psl *mapPsl, int mappedPslMax)
static struct block	blockFromPslBlock (struct psl *psl, int iBlock)
static void	addPslBlock (struct psl *psl, struct block *blk, int *pslMax)
static void	setPslBounds (struct psl *mappedPsl)
static void	adjustOrientation (unsigned opts, struct psl *inPsl, char *inPslOrigStrand, struct psl *mappedPsl)
static struct block	getBeforeBlockMapping (unsigned mqStart, unsigned mqEnd, struct block *align1Blk)
static struct block	getOverBlockMapping (unsigned mqStart, unsigned mqEnd, unsigned mtStart, struct block *align1Blk)
static struct block	getBlockMapping (struct psl *inPsl, struct psl *mapPsl, int *iMapBlkPtr, struct block *align1Blk)
static boolean	mapBlock (struct psl *inPsl, struct psl *mapPsl, int *iMapBlkPtr, struct block *align1Blk, struct psl *mappedPsl, int *mappedPslMax)
psl *	pslTransMap (unsigned opts, struct psl *inPsl, struct psl *mapPsl)

---

Function Documentation

static void addPslBlock	(	struct psl *	psl,
		struct block *	blk,
		int *	pslMax
	)			[static]

Definition at line 91 of file pslTransMap.c.

References psl::blockCount, pslGrow(), block::qEnd, block::qStart, block::tEnd, and block::tStart.

Referenced by mapBlock().

{
unsigned newIBlk = psl->blockCount;

assert((blk->qEnd - blk->qStart) == (blk->tEnd - blk->tStart));
if (newIBlk >= *pslMax)
    pslGrow(psl, pslMax);
psl->qStarts[newIBlk] = blk->qStart;
psl->tStarts[newIBlk] = blk->tStart;
psl->blockSizes[newIBlk] = blk->qEnd - blk->qStart;
/* lie about match counts. */
psl->match += psl->blockSizes[newIBlk];
psl->blockCount++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void adjustOrientation	(	unsigned	opts,
		struct psl *	inPsl,
		char *	inPslOrigStrand,
		struct psl *	mappedPsl
	)			[static]

Definition at line 124 of file pslTransMap.c.

References pslRc(), pslTransMapKeepTrans, pslTStrand, and psl::strand.

Referenced by pslTransMap().

{
if (!(opts&pslTransMapKeepTrans) || ((inPslOrigStrand[1] == '\0') && (mappedPsl->strand[1] == '\0')))
    {
    /* make untranslated */
    if (pslTStrand(mappedPsl) == '-')
        pslRc(mappedPsl);
    mappedPsl->strand[1] = '\0';  /* implied target strand */
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct block blockFromPslBlock	(	struct psl *	psl,
		int	iBlock
	)			[static, read]

Definition at line 80 of file pslTransMap.c.

References block::qEnd, block::qStart, block::tEnd, and block::tStart.

Referenced by pslTransMap().

{
struct block block;
block.qStart = psl->qStarts[iBlock];
block.qEnd = psl->qStarts[iBlock] + psl->blockSizes[iBlock];
block.tStart = psl->tStarts[iBlock];
block.tEnd = psl->tStarts[iBlock] + psl->blockSizes[iBlock];
return block;
}

Here is the caller graph for this function:

static struct psl* createMappedPsl	(	struct psl *	inPsl,
		struct psl *	mapPsl,
		int	mappedPslMax
	)			[static, read]

Definition at line 62 of file pslTransMap.c.

References pslNew(), pslQStrand, pslTStrand, psl::qName, psl::qSize, psl::strand, psl::tName, and psl::tSize.

Referenced by pslTransMap().

{
char strand[3];
assert(pslTStrand(inPsl) == pslQStrand(mapPsl));

/* strand can be taken from both alignments, since common sequence is in same
 * orientation. */
strand[0] = pslQStrand(inPsl);
strand[1] = pslTStrand(mapPsl);
strand[2] = '\n';

return pslNew(inPsl->qName, inPsl->qSize, 0, 0,
              mapPsl->tName, mapPsl->tSize, 0, 0,
              strand, mappedPslMax, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct block getBeforeBlockMapping	(	unsigned	mqStart,
		unsigned	mqEnd,
		struct block *	align1Blk
	)			[static, read]

Definition at line 138 of file pslTransMap.c.

References block::tStart, and ZeroVar.

Referenced by getBlockMapping().

{
struct block mappedBlk;

/* mRNA start in genomic gap before this block, this will
 * be an inPsl insert */
unsigned size = (align1Blk->tEnd < mqStart)
    ? (align1Blk->tEnd - align1Blk->tStart)
    : (mqStart - align1Blk->tStart);
ZeroVar(&mappedBlk);
mappedBlk.qStart = align1Blk->qStart;
mappedBlk.qEnd = align1Blk->qStart + size;
return mappedBlk;
}

Here is the caller graph for this function:

static struct block getBlockMapping	(	struct psl *	inPsl,
		struct psl *	mapPsl,
		int *	iMapBlkPtr,
		struct block *	align1Blk
	)			[static, read]

Definition at line 175 of file pslTransMap.c.

References psl::blockCount, psl::blockSizes, getBeforeBlockMapping(), getOverBlockMapping(), psl::qStarts, and psl::tStarts.

Referenced by mapBlock().

{
int iBlk;
struct block mappedBlk;

/* search for block or gap containing start of mrna block */
for (iBlk = *iMapBlkPtr; iBlk < mapPsl->blockCount; iBlk++)
    {
    unsigned mqStart = mapPsl->qStarts[iBlk];
    unsigned mqEnd = mapPsl->qStarts[iBlk]+mapPsl->blockSizes[iBlk];
    if (align1Blk->tStart < mqStart)
        {
        *iMapBlkPtr = iBlk;
        return getBeforeBlockMapping(mqStart, mqEnd, align1Blk);
        }
    if ((align1Blk->tStart >= mqStart) && (align1Blk->tStart < mqEnd))
        {
        *iMapBlkPtr = iBlk;
        return getOverBlockMapping(mqStart, mqEnd, mapPsl->tStarts[iBlk], align1Blk);
        }
    }

/* reached the end of the mRNA->genome alignment, finish off the 
 * rest of the the protein as an insert */
ZeroVar(&mappedBlk);
mappedBlk.qStart = align1Blk->qStart;
mappedBlk.qEnd = align1Blk->qEnd;
*iMapBlkPtr = iBlk;
return mappedBlk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct block getOverBlockMapping	(	unsigned	mqStart,
		unsigned	mqEnd,
		unsigned	mtStart,
		struct block *	align1Blk
	)			[static, read]

Definition at line 155 of file pslTransMap.c.

References block::tEnd, block::tStart, and ZeroVar.

Referenced by getBlockMapping().

{
struct block mappedBlk;

/* common sequence start contained in this block, this handles aligned
 * and genomic inserts */
unsigned off = align1Blk->tStart - mqStart;
unsigned size = (align1Blk->tEnd > mqEnd)
    ? (mqEnd - align1Blk->tStart)
    : (align1Blk->tEnd - align1Blk->tStart);
ZeroVar(&mappedBlk);
mappedBlk.qStart = align1Blk->qStart;
mappedBlk.qEnd = align1Blk->qStart + size;
mappedBlk.tStart = mtStart + off;
mappedBlk.tEnd = mtStart + off + size;
return mappedBlk;
}

Here is the caller graph for this function:

static boolean mapBlock	(	struct psl *	inPsl,
		struct psl *	mapPsl,
		int *	iMapBlkPtr,
		struct block *	align1Blk,
		struct psl *	mappedPsl,
		int *	mappedPslMax
	)			[static]

Definition at line 213 of file pslTransMap.c.

References addPslBlock(), FALSE, getBlockMapping(), block::qEnd, block::qStart, block::tEnd, TRUE, and block::tStart.

Referenced by pslTransMap().

{
struct block mappedBlk;
unsigned size;
assert(align1Blk->qStart <= align1Blk->qEnd);
assert(align1Blk->tStart <= align1Blk->tEnd);
assert((align1Blk->qEnd - align1Blk->qStart) == (align1Blk->tEnd - align1Blk->tStart));

if ((align1Blk->qStart >= align1Blk->qEnd) || (align1Blk->tStart >= align1Blk->tEnd))
    return FALSE;  /* end of ungapped block. */

/* find block or gap with start coordinates of mrna */
mappedBlk = getBlockMapping(inPsl, mapPsl, iMapBlkPtr, align1Blk);

if ((mappedBlk.qEnd != 0) && (mappedBlk.tEnd != 0))
    addPslBlock(mappedPsl, &mappedBlk, mappedPslMax);

/* advance past block or gap */
size = (mappedBlk.qEnd != 0)
    ? (mappedBlk.qEnd - mappedBlk.qStart)
    : (mappedBlk.tEnd - mappedBlk.tStart);
align1Blk->qStart += size;
align1Blk->tStart += size;

return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void pslNAToProt

(

struct psl *

psl

)

[static]

Definition at line 47 of file pslTransMap.c.

References psl::blockCount, psl::blockSizes, psl::qEnd, psl::qSize, psl::qStart, and psl::qStarts.

Referenced by pslTransMap().

{
int iBlk;

psl->qStart /= 3;
psl->qEnd /= 3;
psl->qSize /= 3;
for (iBlk = 0; iBlk < psl->blockCount; iBlk++)
    {
    psl->blockSizes[iBlk] /= 3;
    psl->qStarts[iBlk] /= 3;
    }
}

Here is the caller graph for this function:

static void pslProtToNA

(

struct psl *

psl

)

[static]

Definition at line 32 of file pslTransMap.c.

References psl::blockCount, psl::blockSizes, psl::qEnd, psl::qSize, psl::qStart, and psl::qStarts.

Referenced by pslTransMap().

{
int iBlk;

psl->qStart *= 3;
psl->qEnd *= 3;
psl->qSize *= 3;
for (iBlk = 0; iBlk < psl->blockCount; iBlk++)
    {
    psl->blockSizes[iBlk] *= 3;
    psl->qStarts[iBlk] *= 3;
    }
}

Here is the caller graph for this function:

struct psl* pslTransMap	(	unsigned	opts,
		struct psl *	inPsl,
		struct psl *	mapPsl
	)			[read]

Definition at line 247 of file pslTransMap.c.

References adjustOrientation(), psl::blockCount, blockFromPslBlock(), createMappedPsl(), errAbort(), mapBlock(), pslFree(), pslIsProtein(), pslNAToProt(), pslProtToNA(), pslQStrand, pslRc(), pslTStrand, psl::qName, psl::qSize, safef(), sameString, setPslBounds(), psl::tName, and psl::tSize.

{
int mappedPslMax = 8; /* allocated space in output psl */
int iMapBlk = 0;
char inPslOrigStrand[3];
boolean rcInPsl = (pslTStrand(inPsl) != pslQStrand(mapPsl));
boolean cnv1 = (pslIsProtein(inPsl) && !pslIsProtein(mapPsl));
boolean cnv2 = (pslIsProtein(mapPsl) && !pslIsProtein(inPsl));
int iBlock;
struct psl* mappedPsl;

if (!sameString(inPsl->tName, mapPsl->qName))
    errAbort("Error: inPsl tName %s != mapPsl tName %s)",
            inPsl->tName, mapPsl->qName);
if (inPsl->tSize != mapPsl->qSize)
    errAbort("Error: inPsl %s tSize (%d) != mapPsl %s qSize (%d)",
            inPsl->tName, inPsl->tSize, mapPsl->qName, mapPsl->qSize);

/* convert protein PSLs */
if (cnv1)
    pslProtToNA(inPsl);
if (cnv2)
    pslProtToNA(mapPsl);

/* need to ensure common sequence is in same orientation, save strand for later */
safef(inPslOrigStrand, sizeof(inPslOrigStrand), "%s", inPsl->strand);
if (rcInPsl)
    pslRc(inPsl);

mappedPsl = createMappedPsl(inPsl, mapPsl, mappedPslMax);

/* Fill in ungapped blocks.  */
for (iBlock = 0; iBlock < inPsl->blockCount; iBlock++)
    {
    struct block align1Blk = blockFromPslBlock(inPsl, iBlock);
    while (mapBlock(inPsl, mapPsl, &iMapBlk, &align1Blk, mappedPsl,
                    &mappedPslMax))
        continue;
    }

/* finish up psl, or free if no blocks were added */
assert(mappedPsl->blockCount <= mappedPslMax);
if (mappedPsl->blockCount == 0)
    pslFree(&mappedPsl);  /* nothing made it */
else
    {
    setPslBounds(mappedPsl);
    adjustOrientation(opts, inPsl, inPslOrigStrand, mappedPsl);
    }

/* restore input */
if (rcInPsl)
    {
    pslRc(inPsl);
    strcpy(inPsl->strand, inPslOrigStrand);
    }
if (cnv1)
    pslNAToProt(inPsl);
if (cnv2)
    pslNAToProt(mapPsl);

return mappedPsl;
}

Here is the call graph for this function:

static void setPslBounds

(

struct psl *

mappedPsl

)

[static]

Definition at line 107 of file pslTransMap.c.

References psl::blockCount, psl::blockSizes, pslQStrand, pslTStrand, psl::qEnd, psl::qSize, psl::qStart, psl::qStarts, reverseIntRange(), psl::tEnd, psl::tSize, psl::tStart, and psl::tStarts.

Referenced by pslTransMap().

{
int lastBlk = mappedPsl->blockCount-1;

/* set start/end of sequences */
mappedPsl->qStart = mappedPsl->qStarts[0];
mappedPsl->qEnd = mappedPsl->qStarts[lastBlk] + mappedPsl->blockSizes[lastBlk];
if (pslQStrand(mappedPsl) == '-')
    reverseIntRange(&mappedPsl->qStart, &mappedPsl->qEnd, mappedPsl->qSize);

mappedPsl->tStart = mappedPsl->tStarts[0];
mappedPsl->tEnd = mappedPsl->tStarts[lastBlk] + mappedPsl->blockSizes[lastBlk];
if (pslTStrand(mappedPsl) == '-')
    reverseIntRange(&mappedPsl->tStart, &mappedPsl->tEnd, mappedPsl->tSize);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---