struct altProbe *altProbeLoad(char **row)
/* Load a altProbe from row fetched with select * from altProbe
* from database. Dispose of this with altProbeFree(). */
{
struct altProbe *ret;
int sizeOne;
AllocVar(ret);
ret->contProbeCount = sqlSigned(row[7]);
ret->alt1ProbeCount = sqlSigned(row[9]);
ret->alt2ProbeCount = sqlSigned(row[11]);
ret->transcriptCount = sqlSigned(row[13]);
ret->chrom = cloneString(row[0]);
ret->chromStart = sqlSigned(row[1]);
ret->chromEnd = sqlSigned(row[2]);
ret->type = sqlSigned(row[3]);
strcpy(ret->strand, row[4]);
ret->name = cloneString(row[5]);
ret->maxCounts = sqlSigned(row[6]);
sqlStringDynamicArray(row[8], &ret->contProbeSets, &sizeOne);
assert(sizeOne == ret->contProbeCount);
sqlStringDynamicArray(row[10], &ret->alt1ProbeSets, &sizeOne);
assert(sizeOne == ret->alt1ProbeCount);
sqlStringDynamicArray(row[12], &ret->alt2ProbeSets, &sizeOne);
assert(sizeOne == ret->alt2ProbeCount);
sqlStringDynamicArray(row[14], &ret->transcriptNames, &sizeOne);
assert(sizeOne == ret->transcriptCount);
return ret;
}
struct snp125CodingCoordless *snp125CodingCoordlessLoad(char **row)
/* Load a snp125CodingCoordless from row fetched with select * from snp125CodingCoordless
* from database. Dispose of this with snp125CodingCoordlessFree(). */
{
struct snp125CodingCoordless *ret;
AllocVar(ret);
ret->alleleCount = sqlSigned(row[3]);
ret->name = cloneString(row[0]);
ret->transcript = cloneString(row[1]);
ret->frame = sqlEnumParse(row[2], values_frame, &valhash_frame);
{
int sizeOne;
sqlUshortDynamicArray(row[4], &ret->funcCodes, &sizeOne);
assert(sizeOne == ret->alleleCount);
}
{
int sizeOne;
sqlStringDynamicArray(row[5], &ret->alleles, &sizeOne);
assert(sizeOne == ret->alleleCount);
}
{
int sizeOne;
sqlStringDynamicArray(row[6], &ret->codons, &sizeOne);
assert(sizeOne == ret->alleleCount);
}
{
int sizeOne;
sqlStringDynamicArray(row[7], &ret->peptides, &sizeOne);
assert(sizeOne == ret->alleleCount);
}
return ret;
}
struct rikenUcscCluster *rikenUcscClusterLoad(char **row)
/* Load a rikenUcscCluster from row fetched with select * from rikenUcscCluster
* from database. Dispose of this with rikenUcscClusterFree(). */
{
struct rikenUcscCluster *ret;
int sizeOne;
AllocVar(ret);
ret->refSeqCount = sqlUnsigned(row[6]);
ret->genBankCount = sqlUnsigned(row[8]);
ret->rikenCount = sqlUnsigned(row[10]);
ret->chrom = cloneString(row[0]);
ret->chromStart = sqlUnsigned(row[1]);
ret->chromEnd = sqlUnsigned(row[2]);
ret->name = cloneString(row[3]);
ret->score = sqlUnsigned(row[4]);
strcpy(ret->strand, row[5]);
sqlStringDynamicArray(row[7], &ret->refSeqs, &sizeOne);
assert(sizeOne == ret->refSeqCount);
sqlStringDynamicArray(row[9], &ret->genBanks, &sizeOne);
assert(sizeOne == ret->genBankCount);
sqlStringDynamicArray(row[11], &ret->rikens, &sizeOne);
assert(sizeOne == ret->rikenCount);
return ret;
}
struct cutter *cutterLoad(char **row)
/* Load a cutter from row fetched with select * from cutter
* from database. Dispose of this with cutterFree(). */
{
struct cutter *ret;
AllocVar(ret);
ret->numSciz = sqlUnsigned(row[8]);
ret->numCompanies = sqlUnsigned(row[10]);
ret->numRefs = sqlUnsigned(row[12]);
ret->name = cloneString(row[0]);
ret->size = sqlUnsigned(row[1]);
ret->matchSize = sqlUnsigned(row[2]);
ret->seq = cloneString(row[3]);
ret->cut = sqlUnsigned(row[4]);
ret->overhang = sqlSigned(row[5]);
ret->palindromic = sqlUnsigned(row[6]);
ret->semicolon = sqlUnsigned(row[7]);
{
int sizeOne;
sqlStringDynamicArray(row[9], &ret->scizs, &sizeOne);
assert(sizeOne == ret->numSciz);
}
{
int sizeOne;
sqlCharDynamicArray(row[11], &ret->companies, &sizeOne);
assert(sizeOne == ret->numCompanies);
}
{
int sizeOne;
sqlUnsignedDynamicArray(row[13], &ret->refs, &sizeOne);
assert(sizeOne == ret->numRefs);
}
return ret;
}
struct fosEndPairs *fosEndPairsLoad(char **row)
/* Load a fosEndPairs from row fetched with select * from fosEndPairs
* from database. Dispose of this with fosEndPairsFree(). */
{
struct fosEndPairs *ret;
int sizeOne,i;
char *s;
AllocVar(ret);
ret->lfCount = sqlUnsigned(row[8]);
ret->bin = sqlSigned(row[0]);
ret->chrom = cloneString(row[1]);
ret->chromStart = sqlUnsigned(row[2]);
ret->chromEnd = sqlUnsigned(row[3]);
ret->name = cloneString(row[4]);
ret->score = sqlUnsigned(row[5]);
strcpy(ret->strand, row[6]);
ret->pslTable = cloneString(row[7]);
sqlUnsignedDynamicArray(row[9], &ret->lfStarts, &sizeOne);
assert(sizeOne == ret->lfCount);
sqlUnsignedDynamicArray(row[10], &ret->lfSizes, &sizeOne);
assert(sizeOne == ret->lfCount);
sqlStringDynamicArray(row[11], &ret->lfNames, &sizeOne);
assert(sizeOne == ret->lfCount);
return ret;
}
void removeElement(char *el, char ***array, unsigned *count)
/* Add a new element to a array of elements */
{
char *arrayCurr, *arrayCurrDel, del[128];
int sizeOne, size;
char **cArray, **rArray=NULL, ***dArray;
if (*count > 0)
{
size = *count;
arrayCurr = sqlStringArrayToString(*array, *count);
safef(del, ArraySize(del), "%s,", el);
arrayCurrDel = replaceChars(arrayCurr, del, "");
if (differentString(arrayCurr, arrayCurrDel))
size--;
dArray = array;
/* if (*dArray)
freeMem(dArray); */
sqlStringDynamicArray(arrayCurrDel, &cArray, &sizeOne);
assert(sizeOne == size);
*count = size;
if (size > 0)
{
AllocArray(rArray, size);
CopyArray(cArray, rArray, size);
*array = rArray;
}
else
*array = NULL;
}
}
void addElement(char *el, char ***array, unsigned *count)
/* Add a new element to a array of elements */
{
char *arrayCurr, arrayNew[MAX_ID_LIST];
int sizeOne, size;
char **cArray, **rArray=NULL, ***dArray;
/* Check if already present in array */
if (!inArray(el, *array, *count))
{
size = *count;
arrayCurr = sqlStringArrayToString(*array, *count);
safef(arrayNew, ArraySize(arrayNew), "%s%s,", arrayCurr, el);
size++;
dArray = array;
/* if (*dArray)
freeMem(dArray); */
sqlStringDynamicArray(arrayNew, &cArray, &sizeOne);
assert(sizeOne == size);
*count = size;
AllocArray(rArray, size);
CopyArray(cArray, rArray, size);
*array = rArray;
}
}
struct zdobnovSynt *zdobnovSyntLoad(char **row)
/* Load a zdobnovSynt from row fetched with select * from zdobnovSynt
* from database. Dispose of this with zdobnovSyntFree(). */
{
struct zdobnovSynt *ret;
int sizeOne;
AllocVar(ret);
ret->blockCount = sqlSigned(row[9]);
ret->chrom = cloneString(row[0]);
ret->chromStart = sqlUnsigned(row[1]);
ret->chromEnd = sqlUnsigned(row[2]);
ret->name = cloneString(row[3]);
ret->score = sqlUnsigned(row[4]);
strcpy(ret->strand, row[5]);
ret->thickStart = sqlUnsigned(row[6]);
ret->thickEnd = sqlUnsigned(row[7]);
ret->reserved = sqlUnsigned(row[8]);
sqlSignedDynamicArray(row[10], &ret->blockSizes, &sizeOne);
assert(sizeOne == ret->blockCount);
sqlSignedDynamicArray(row[11], &ret->chromStarts, &sizeOne);
assert(sizeOne == ret->blockCount);
sqlStringDynamicArray(row[12], &ret->geneNames, &sizeOne);
assert(sizeOne == ret->blockCount);
return ret;
}
struct autoTest *autoTestLoad(char **row)
/* Load a autoTest from row fetched with select * from autoTest
* from database. Dispose of this with autoTestFree(). */
{
struct autoTest *ret;
AllocVar(ret);
ret->ptCount = sqlSigned(row[5]);
ret->difCount = sqlSigned(row[7]);
ret->valCount = sqlSigned(row[10]);
ret->id = sqlUnsigned(row[0]);
safecpy(ret->shortName, sizeof(ret->shortName), row[1]);
ret->longName = cloneString(row[2]);
{
char *s = cloneString(row[3]);
sqlStringArray(s, ret->aliases, 3);
}
{
char *s = row[4];
if(s != NULL && differentString(s, ""))
ret->threeD = pointCommaIn(&s, NULL);
}
{
int sizeOne;
sqlShortDynamicArray(row[6], &ret->pts, &sizeOne);
assert(sizeOne == ret->ptCount);
}
{
int sizeOne;
sqlUbyteDynamicArray(row[8], &ret->difs, &sizeOne);
assert(sizeOne == ret->difCount);
}
sqlSignedArray(row[9], ret->xy, 2);
{
int sizeOne;
sqlStringDynamicArray(row[11], &ret->vals, &sizeOne);
assert(sizeOne == ret->valCount);
}
ret->dblVal = sqlDouble(row[12]);
ret->fltVal = sqlFloat(row[13]);
{
int sizeOne;
sqlDoubleDynamicArray(row[14], &ret->dblArray, &sizeOne);
assert(sizeOne == ret->valCount);
}
{
int sizeOne;
sqlFloatDynamicArray(row[15], &ret->fltArray, &sizeOne);
assert(sizeOne == ret->valCount);
}
return ret;
}
struct xAli *xAliLoad(char **row)
/* Load a xAli from row fetched with select * from xAli
* from database. Dispose of this with xAliFree(). */
{
struct xAli *ret;
int sizeOne;
AllocVar(ret);
ret->blockCount = sqlUnsigned(row[17]);
ret->match = sqlUnsigned(row[0]);
ret->misMatch = sqlUnsigned(row[1]);
ret->repMatch = sqlUnsigned(row[2]);
ret->nCount = sqlUnsigned(row[3]);
ret->qNumInsert = sqlUnsigned(row[4]);
ret->qBaseInsert = sqlSigned(row[5]);
ret->tNumInsert = sqlUnsigned(row[6]);
ret->tBaseInsert = sqlSigned(row[7]);
strcpy(ret->strand, row[8]);
ret->qName = cloneString(row[9]);
ret->qSize = sqlUnsigned(row[10]);
ret->qStart = sqlUnsigned(row[11]);
ret->qEnd = sqlUnsigned(row[12]);
ret->tName = cloneString(row[13]);
ret->tSize = sqlUnsigned(row[14]);
ret->tStart = sqlUnsigned(row[15]);
ret->tEnd = sqlUnsigned(row[16]);
sqlUnsignedDynamicArray(row[18], &ret->blockSizes, &sizeOne);
assert(sizeOne == ret->blockCount);
sqlUnsignedDynamicArray(row[19], &ret->qStarts, &sizeOne);
assert(sizeOne == ret->blockCount);
sqlUnsignedDynamicArray(row[20], &ret->tStarts, &sizeOne);
assert(sizeOne == ret->blockCount);
sqlStringDynamicArray(row[21], &ret->qSeq, &sizeOne);
assert(sizeOne == ret->blockCount);
sqlStringDynamicArray(row[22], &ret->tSeq, &sizeOne);
assert(sizeOne == ret->blockCount);
return ret;
}
struct mrnaMisMatch *mrnaMisMatchLoad(char **row)
/* Load a mrnaMisMatch from row fetched with select * from mrnaMisMatch
* from database. Dispose of this with mrnaMisMatchFree(). */
{
struct mrnaMisMatch *ret;
AllocVar(ret);
ret->misMatchCount = sqlSigned(row[3]);
ret->snpCount = sqlSigned(row[9]);
ret->name = cloneString(row[0]);
ret->mrnaBase = row[1][0];
ret->mrnaLoc = sqlSigned(row[2]);
ret->bases = cloneString(row[4]);
{
int sizeOne;
sqlStringDynamicArray(row[5], &ret->chroms, &sizeOne);
assert(sizeOne == ret->misMatchCount);
}
{
int sizeOne;
sqlUnsignedDynamicArray(row[6], &ret->tStarts, &sizeOne);
assert(sizeOne == ret->misMatchCount);
}
ret->strands = cloneString(row[7]);
{
int sizeOne;
sqlUnsignedDynamicArray(row[8], &ret->loci, &sizeOne);
assert(sizeOne == ret->misMatchCount);
}
{
int sizeOne;
sqlStringDynamicArray(row[10], &ret->snps, &sizeOne);
assert(sizeOne == ret->snpCount);
}
return ret;
}
struct geneBands *geneBandsLoad(char **row)
/* Load a geneBands from row fetched with select * from geneBands
* from database. Dispose of this with geneBandsFree(). */
{
struct geneBands *ret;
int sizeOne;
AllocVar(ret);
ret->count = sqlSigned(row[2]);
ret->name = cloneString(row[0]);
ret->mrnaAcc = cloneString(row[1]);
sqlStringDynamicArray(row[3], &ret->bands, &sizeOne);
assert(sizeOne == ret->count);
return ret;
}
struct tigrOperon *tigrOperonLoad(char **row)
/* Load a tigrOperon from row fetched with select * from tigrOperon
* from database. Dispose of this with tigrOperonFree(). */
{
struct tigrOperon *ret;
AllocVar(ret);
ret->size = sqlUnsigned(row[1]);
ret->name = cloneString(row[0]);
{
int sizeOne;
sqlStringDynamicArray(row[2], &ret->genes, &sizeOne);
assert(sizeOne == ret->size);
}
ret->info = cloneString(row[3]);
return ret;
}
struct txCluster *txClusterLoad(char **row)
/* Load a txCluster from row fetched with select * from txCluster
* from database. Dispose of this with txClusterFree(). */
{
struct txCluster *ret;
AllocVar(ret);
ret->txCount = sqlSigned(row[6]);
ret->chrom = cloneString(row[0]);
ret->chromStart = sqlSigned(row[1]);
ret->chromEnd = sqlSigned(row[2]);
ret->name = cloneString(row[3]);
ret->score = sqlSigned(row[4]);
safecpy(ret->strand, sizeof(ret->strand), row[5]);
{
int sizeOne;
sqlStringDynamicArray(row[7], &ret->txArray, &sizeOne);
assert(sizeOne == ret->txCount);
}
return ret;
}
struct imageClone *imageCloneLoad(char **row)
/* Load a imageClone from row fetched with select * from imageClone
* from database. Dispose of this with imageCloneFree(). */
{
struct imageClone *ret;
int sizeOne = 0;
AllocVar(ret);
ret->numGenbank = sqlSigned(row[7]);
ret->id = sqlUnsigned(row[0]);
ret->library = cloneString(row[1]);
ret->plateNum = sqlUnsigned(row[2]);
ret->row = cloneString(row[3]);
ret->column = sqlUnsigned(row[4]);
ret->libId = sqlUnsigned(row[5]);
ret->organism = cloneString(row[6]);
if(ret->numGenbank > 0) {
sqlStringDynamicArray(row[8], &ret->genbankIds, &sizeOne);
}
assert(sizeOne == ret->numGenbank);
return ret;
}
struct exprBed *exprBedLoad(char **row)
/* Load a exprBed from row fetched with select * from exprBed
* from database. Dispose of this with exprBedFree(). */
{
struct exprBed *ret;
int sizeOne;
AllocVar(ret);
ret->numExp = sqlUnsigned(row[8]);
ret->chrom = cloneString(row[0]);
ret->chromStart = sqlUnsigned(row[1]);
ret->chromEnd = sqlUnsigned(row[2]);
ret->name = cloneString(row[3]);
ret->size = sqlUnsigned(row[4]);
ret->uniqueAlign = sqlUnsigned(row[5]);
ret->score = sqlUnsigned(row[6]);
ret->hname = cloneString(row[7]);
sqlStringDynamicArray(row[9], &ret->hybes, &sizeOne);
assert(sizeOne == ret->numExp);
sqlFloatDynamicArray(row[10], &ret->scores, &sizeOne);
assert(sizeOne == ret->numExp);
return ret;
}
void initStep(struct sqlConnection *conn, struct stepInit *init)
/* Create step based on initializer */
{
/* Do a little validation on while counting up inputs and outputs */
int inCount = commaSepCount(init->inputTypes);
int matchCount = commaSepCount(init->inputFormats);
if (inCount != matchCount)
errAbort("inputTypes has %d elements but inputFormats has %d in step %s",
inCount, matchCount, init->name);
int outCount = commaSepCount(init->outputTypes);
matchCount = commaSepCount(init->outputFormats);
if (outCount != matchCount)
errAbort("outputTypes has %d elements but outputFormats has %d in step %s",
outCount, matchCount, init->name);
matchCount = commaSepCount(init->outputNamesInTempDir);
if (outCount != matchCount)
errAbort("outputTypes has %d elements but outputNamesInTempDir has %d in step %s",
outCount, matchCount, init->name);
struct dyString *query = dyStringNew(0);
dyStringPrintf(query, "select count(*) from eapStep where name='%s'", init->name);
int existingCount = sqlQuickNum(conn, query->string);
if (existingCount > 0)
{
warn("%s already exists in eapStep", init->name);
dyStringFree(&query);
return;
}
/* Parse out software part and make sure that all pieces are there. */
char **softwareArray;
int softwareCount;
sqlStringDynamicArray(init->software, &softwareArray, &softwareCount);
unsigned softwareIds[softwareCount];
int i;
for (i=0; i<softwareCount; ++i)
{
char *name = softwareArray[i];
dyStringClear(query);
dyStringPrintf(query, "select id from eapSoftware where name='%s'", name);
unsigned softwareId = sqlQuickNum(conn, query->string);
if (softwareId == 0)
errAbort("Software %s doesn't exist by that name in eapSoftware", name);
softwareIds[i] = softwareId;
}
/* Make step record. */
dyStringClear(query);
dyStringAppend(query,
"insert eapStep (name,cpusRequested,"
" inCount,inputTypes,inputFormats,"
" outCount,outputNamesInTempDir,outputTypes,outputFormats)"
" values (");
dyStringPrintf(query, "'%s',", init->name);
dyStringPrintf(query, "%d,", init->cpusRequested);
dyStringPrintf(query, "%d,", inCount);
dyStringPrintf(query, "'%s',", init->inputTypes);
dyStringPrintf(query, "'%s',", init->inputFormats);
dyStringPrintf(query, "%d,", outCount);
dyStringPrintf(query, "'%s',", init->outputNamesInTempDir);
dyStringPrintf(query, "'%s',", init->outputTypes);
dyStringPrintf(query, "'%s'", init->outputFormats);
dyStringPrintf(query, ")");
sqlUpdate(conn, query->string);
/* Make software/step associations. */
for (i=0; i<softwareCount; ++i)
{
dyStringClear(query);
dyStringPrintf(query, "insert eapStepSoftware (step,software) values ('%s','%s')",
init->name, softwareArray[i]);
sqlUpdate(conn, query->string);
}
/* Force step version stuff to be made right away */
eapCurrentStepVersion(conn, init->name);
/* Clean up. */
dyStringFree(&query);
freez(&softwareArray[0]);
freez(&softwareArray);
}
void reportCassette(struct altGraphX *ag, bool **em, int vs, int ve1, int ve2,
int altBpStart, int altBpEnd, int startV, int endV, FILE *out)
/* Write out both an altGraphX and two bed files. For a cassette exon the
edges are -
Name Vertexes Class
------ ---------- -----
exon1: startV->vs constitutive (cons 0)
junction1: vs->ve1 alternative1 (alt1 1)
exon2: ve1->altBpEnd alternative1 (alt1 1)
junction2: altBpEnd->ve2 alternative1 (alt1 1)
exon3: ve2->endV constitutive (cons 0)
junction3: vs->ve2 alternative2 (alt2 2)
*/
{
struct altGraphX *agLoc = NULL; /* Local altGraphX. */
struct evidence *ev = NULL, *evLoc = NULL;
int *vPos = ag->vPositions;
unsigned char *vT = ag->vTypes;
int *vPosLoc = NULL; /* Vertex Positions. */
int *eStartsLoc = NULL; /* Edge Starts. */
int *eEndsLoc = NULL; /* Edge ends. */
unsigned char *vTLoc = NULL; /* Vertex Types. */
int *eTLoc = NULL; /* Edge Types. */
int vCLoc = 0;
int eCLoc = 0;
int i =0;
struct dyString *dy = NULL;
if(out == NULL)
return;
AllocVar(agLoc);
agLoc->tName = cloneString(ag->tName);
agLoc->name = cloneString(ag->name);
agLoc->tStart = vPos[startV];
agLoc->tEnd = vPos[endV];
agLoc->strand[0] = ag->strand[0];
agLoc->vertexCount = vCLoc = 6;
agLoc->edgeCount = eCLoc = 6;
agLoc->id = altCassette;
/* Allocate some arrays. */
AllocArray(vPosLoc, vCLoc);
AllocArray(eStartsLoc, vCLoc);
AllocArray(eEndsLoc, vCLoc);
AllocArray(vTLoc, vCLoc);
AllocArray(eTLoc, vCLoc);
/* Fill in the vertex positions. */
vPosLoc[0] = vPos[startV];
vPosLoc[1] = vPos[vs];
vPosLoc[2] = vPos[ve1];
vPosLoc[3] = vPos[altBpEnd];
vPosLoc[4] = vPos[ve2];
vPosLoc[5] = vPos[endV];
/* Fill in the vertex types. */
vTLoc[0] = vT[startV];
vTLoc[1] = vT[vs];
vTLoc[2] = vT[ve1];
vTLoc[3] = vT[altBpEnd];
vTLoc[4] = vT[ve2];
vTLoc[5] = vT[endV];
/* Fill in the edges. */
/* Constitutive first exon. */
eStartsLoc[0] = 0;
eEndsLoc[0] = 1;
eTLoc[0] = 0;
ev = evidenceForEdge(ag, startV, vs);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
/* Exon inclusion junction. */
eStartsLoc[1] = 1;
eEndsLoc[1] = 2;
eTLoc[1] = 1;
ev = evidenceForEdge(ag, vs, ve1);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
/* Exon exclusion junction. */
eStartsLoc[2] = 1;
eEndsLoc[2] = 4;
eTLoc[2] = 2;
ev = evidenceForEdge(ag, vs, ve2);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
/* Cassette exon. */
eStartsLoc[3] = 2;
eEndsLoc[3] = 3;
eTLoc[3] = 1;
ev = evidenceForEdge(ag, ve1, altBpEnd);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
/* Exon inclusion junction. */
eStartsLoc[4] = 3;
eEndsLoc[4] = 4;
eTLoc[4] = 1;
ev = evidenceForEdge(ag, altBpEnd, ve2);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
/* Constitutive second exon. */
eStartsLoc[5] = 4;
eEndsLoc[5] = 5;
eTLoc[5] = 0;
ev = evidenceForEdge(ag, ve2, endV);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
slReverse(&agLoc->evidence);
dy = newDyString(ag->mrnaRefCount*36);
agLoc->mrnaRefCount = ag->mrnaRefCount;
for(i=0; i<ag->mrnaRefCount; i++)
dyStringPrintf(dy, "%s,", ag->mrnaRefs[i]);
sqlStringDynamicArray(dy->string, &agLoc->mrnaRefs, &i);
dyStringFree(&dy);
agLoc->mrnaTissues = CloneArray(ag->mrnaTissues, ag->mrnaRefCount);
agLoc->mrnaLibs = CloneArray(ag->mrnaLibs, ag->mrnaRefCount);
agLoc->vPositions = vPosLoc;
agLoc->edgeStarts = eStartsLoc;
agLoc->edgeEnds = eEndsLoc;
agLoc->vTypes = vTLoc;
agLoc->edgeTypes = eTLoc;
altGraphXTabOut(agLoc, out);
altGraphXFree(&agLoc);
}
void reportAlt3Prime(struct altGraphX *ag, bool **em, int vs, int ve1, int ve2,
int altBpStart, int altBpEnd, int startV, int endV, FILE *out)
/* Write out an altGraphX record for an alt3Prime splicing
event. Variable names are consistent with the rest of the program, but
can be misleading. Specifically vs = start of alt splicing, ve1 =
first end of alt splicing, etc. even though "vs" is really the end of
an exon. For an alt5Prime splice the edges are:
Name Vertexes Class
------ ---------- -----
exon1: startV->vs constituative (0)
junction1: vs->ve1 alternative (1)
junction2: vs->ve2 alternative (2)
exon2: ve1->e2 alternative (1)
exon3: ve2->endV constituative (0)
*/
{
struct altGraphX *agLoc = NULL; /* Local altGraphX. */
struct evidence *ev = NULL, *evLoc = NULL;
int *vPos = ag->vPositions;
unsigned char *vT = ag->vTypes;
int *vPosLoc = NULL; /* Vertex Positions. */
int *eStartsLoc = NULL; /* Edge Starts. */
int *eEndsLoc = NULL; /* Edge ends. */
unsigned char *vTLoc = NULL; /* Vertex Types. */
int *eTLoc = NULL; /* Edge Types. */
int vCLoc = 0;
int eCLoc = 0;
int edgeIx = 0, vertexIx = 0;
int i =0;
struct dyString *dy = NULL;
if(out == NULL)
return;
AllocVar(agLoc);
agLoc->tName = cloneString(ag->tName);
agLoc->name = cloneString(ag->name);
agLoc->tStart = vPos[startV];
agLoc->tEnd = vPos[endV];
agLoc->strand[0] = ag->strand[0];
agLoc->vertexCount = vCLoc = 6;
agLoc->edgeCount = eCLoc = 5;
agLoc->id = alt3Prime;
/* Allocate some arrays. */
AllocArray(vPosLoc, vCLoc);
AllocArray(eStartsLoc, eCLoc);
AllocArray(eEndsLoc, eCLoc);
AllocArray(vTLoc, vCLoc);
AllocArray(eTLoc, eCLoc);
/* Fill in the vertex positions. */
vertexIx = 0;
vPosLoc[vertexIx++] = vPos[startV]; /* 0 */
vPosLoc[vertexIx++] = vPos[vs]; /* 1 */
vPosLoc[vertexIx++] = vPos[ve1]; /* 2 */
vPosLoc[vertexIx++] = vPos[ve2]; /* 3 */
vPosLoc[vertexIx++] = vPos[ve2]; /* 4 */
vPosLoc[vertexIx++] = vPos[endV]; /* 5 */
/* Fill in the vertex types. */
vertexIx = 0;
vTLoc[vertexIx++] = vT[startV];
vTLoc[vertexIx++] = vT[vs];
vTLoc[vertexIx++] = vT[ve1];
vTLoc[vertexIx++] = vT[vs]; /* Faking a separate exon for the alt spliced portion. */
vTLoc[vertexIx++] = vT[ve2];
vTLoc[vertexIx++] = vT[endV];
edgeIx = 0;
/* Constitutive first exon. */
eStartsLoc[edgeIx] = 0;
eEndsLoc[edgeIx] = 1;
eTLoc[edgeIx] = 0;
ev = evidenceForEdge(ag, startV, vs);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
edgeIx++;
/* Alternative1 junction (shorter). */
eStartsLoc[edgeIx] = 1;
eEndsLoc[edgeIx] = 2;
eTLoc[edgeIx] = 1;
ev = evidenceForEdge(ag, vs, ve1);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
edgeIx++;
/* Alt2 junction (longer). */
eStartsLoc[edgeIx] = 1;
eEndsLoc[edgeIx] = 4;
eTLoc[edgeIx] = 2;
ev = evidenceForEdge(ag, vs, ve2);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
edgeIx++;
/* Alt1 portion of second exon. */
eStartsLoc[edgeIx] = 2;
eEndsLoc[edgeIx] = 3;
eTLoc[edgeIx] = 1;
ev = evidenceForEdge(ag, ve1, endV);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
edgeIx++;
/* Exon 2 constitutive (shorter exon) */
eStartsLoc[edgeIx] = 4;
eEndsLoc[edgeIx] = 5;
eTLoc[edgeIx] = 0;
ev = evidenceForEdge(ag, ve2, endV);
evLoc = CloneVar(ev);
evLoc->mrnaIds = CloneArray(ev->mrnaIds, ev->evCount);
slAddHead(&agLoc->evidence, evLoc);
edgeIx++;
/* Package up the evidence, tissues, etc. */
slReverse(&agLoc->evidence);
dy = newDyString(ag->mrnaRefCount*36);
agLoc->mrnaRefCount = ag->mrnaRefCount;
for(i=0; i<ag->mrnaRefCount; i++)
dyStringPrintf(dy, "%s,", ag->mrnaRefs[i]);
sqlStringDynamicArray(dy->string, &agLoc->mrnaRefs, &i);
dyStringFree(&dy);
agLoc->mrnaTissues = CloneArray(ag->mrnaTissues, ag->mrnaRefCount);
agLoc->mrnaLibs = CloneArray(ag->mrnaLibs, ag->mrnaRefCount);
agLoc->vPositions = vPosLoc;
agLoc->edgeStarts = eStartsLoc;
agLoc->edgeEnds = eEndsLoc;
agLoc->vTypes = vTLoc;
agLoc->edgeTypes = eTLoc;
altGraphXTabOut(agLoc, out);
altGraphXFree(&agLoc);
}
