/* Initialise: set up global data storage */
void Initialise(char *datafn)
{
ParmBuf pbuf;
int s;
Boolean eSep;
CreateHeap(&iStack,"inBuf", MSTAK, 1, 0.5, 100000, LONG_MAX);
CreateHeap(&dStack,"seqStack", MSTAK, 1, 0.5, 100000, LONG_MAX);
CreateHeap(&cStack,"clustStack",MSTAK, 1, 0.5, 100000, LONG_MAX);
/* Peek at first data file to get observation format */
if((pbuf = OpenBuffer(&iStack, datafn, 0, UNDEFF, FALSE_dup, FALSE_dup))==NULL)
HError(2550,"Initialise: Config parameters invalid");
GetBufferInfo(pbuf, &info);
CloseBuffer(pbuf);
ResetHeap(&iStack);
/* set/validate stream widths */
if(swidth[0] > 0)
CheckStreamWidths(info);
else
ZeroStreamWidths(1,swidth);
/* Create an observation to hold the input parameters */
SetStreamWidths(info.tgtPK,info.tgtVecSize,swidth,&eSep);
obs = MakeObservation(&gstack,swidth,info.tgtPK,FALSE,eSep);
if (segLab != NULL)
segId = GetLabId(segLab,TRUE);
/* Create sequences to hold all data*/
for (s=1;s<=swidth[0];s++)
dSeq[s] = CreateSequence(&dStack,4096);
}
cFourFractals::cFourFractals(const cFractalContainer *par, const cParameterContainer *generalPar)
{
fourFractals = new cFractal*[NUMBER_OF_FRACTALS];
for (int i = 0; i < NUMBER_OF_FRACTALS; i++)
{
fourFractals[i] = new cFractal(&par->at(i));
fourFractals[i]->formula = (fractal::enumFractalFormula) generalPar->Get<int>("formula", i + 1);
formulaWeight[i] = generalPar->Get<double>("formula_weight", i + 1);
}
maxN = generalPar->Get<int>("N");
CreateSequence(generalPar);
if (generalPar->Get<bool>("hybrid_fractal_enable"))
{
DEType[0] = fractal::deltaDE;
}
else
{
for(int f = 0; f < NUMBER_OF_FRACTALS; f++)
{
fractal::enumFractalFormula formula = fourFractals[f]->formula;
for (int i = 0; i < fractalList.size(); i++)
{
if (fractalList[i].internalID == formula)
{
DEType[f] = fractalList[i].DEType;
}
}
}
}
}
/* Converts a multiple alignment (possibly with gaps) to a bunch of
* aligned single-letter seqeunces. Also reorders aligned residues.
*/
SequenceAlignment *GetSequenceAlignment(MultipleAlignment *ma) {
SequenceAlignment *out = (SequenceAlignment *) malloc(sizeof(SequenceAlignment));
int chain, block, chain2;
int *indices = (int*) calloc(ma->numChains, sizeof(int));
out->numSeqs = ma->numChains;
out->seqs = (Sequence**) malloc(sizeof(Sequence*) * ma->numChains);
for (chain=0; chain<ma->numChains; chain++) {
out->seqs[chain] = CreateSequence(ma->chains[chain]->pdb->idString);
}
for (block=0; block < ma->numBlocks; block++) {
int first = ma->blocks[block].first;
int last = ma->blocks[block].last;
for (chain=0; chain<ma->numChains; chain++) {
int find = first;
int index;
while (find <= last && !ma->residues[chain].res[find].exists) find++;
if (find > last) break;
index = ma->residues[chain].res[find].index;
while (indices[chain] < index) {
for (chain2=0; chain2<ma->numChains; chain2++) {
if (chain2 != chain) {
AddCharacter(out->seqs[chain2], '-');
}
else {
AddCharacter(out->seqs[chain2], ma->chains[chain2]->res[indices[chain2]++].residue);
}
}
}
}
while (first <= last) {
for (chain=0; chain<ma->numChains; chain++) {
if (ma->residues[chain].res[first].exists) {
AddCharacter(out->seqs[chain], ma->chains[chain]->res[indices[chain]++].residue);
}
else {
AddCharacter(out->seqs[chain], '-');
}
}
first++;
}
}
for (chain=0; chain<ma->numChains; chain++) {
while (indices[chain] < ma->chains[chain]->length) {
for (chain2=0; chain2<ma->numChains; chain2++) {
if (chain2 != chain) {
AddCharacter(out->seqs[chain2], '-');
}
else {
AddCharacter(out->seqs[chain2], ma->chains[chain2]->res[indices[chain2]++].residue);
}
}
}
}
free(indices);
Reorder(out);
return out;
}
List *OrderedList::SelectOrder(ListComparator Compare, BOOL Reverse)
{
if (Compare == NULL || Compare == Unsorted)
return(&MasterList);
OrderSequence *TheSeq = FindSequence(Compare, Reverse); // Find existing Seq?
if (TheSeq == NULL) // No - create new one
TheSeq = CreateSequence(Compare, Reverse);
if (TheSeq == NULL) // Failed - argh!
return(NULL);
if (!TheSeq->Cached) // Needs sorting?
SortSequence(TheSeq);
TheSeq->UsageCount++; // Increment the usage count
return(&TheSeq->Sequence);
}
