--- /dev/null
+/* -*- mode: c; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+/*********************************************************************
+ * Clustal Omega - Multiple sequence alignment
+ *
+ * Copyright (C) 2010 University College Dublin
+ *
+ * Clustal-Omega is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This file is part of Clustal-Omega.
+ *
+ ********************************************************************/
+
+/*
+ * RCS $Id: hhfullalignment-C.h 243 2011-05-31 13:49:19Z fabian $
+ */
+
+// hhfullalignment.C
+
+#ifndef MAIN
+#define MAIN
+#include <iostream> // cin, cout, cerr
+#include <fstream> // ofstream, ifstream
+#include <stdio.h> // printf
+#include <stdlib.h> // exit
+#include <string> // strcmp, strstr
+#include <math.h> // sqrt, pow
+#include <limits.h> // INT_MIN
+#include <float.h> // FLT_MIN
+#include <time.h> // clock
+#include <ctype.h> // islower, isdigit etc
+using std::ios;
+using std::ifstream;
+using std::ofstream;
+using std::cout;
+using std::cerr;
+using std::endl;
+#include "util-C.h" // imax, fmax, iround, iceil, ifloor, strint, strscn, strcut, substr, uprstr, uprchr, Basename etc.
+#include "list.h" // list data structure
+#include "hash.h" // hash data structure
+#include "hhdecl-C.h" // constants, class
+#include "hhutil-C.h" // imax, fmax, iround, iceil, ifloor, strint, strscn, strcut, substr, uprstr, uprchr, Basename etc.
+#include "hhhmm.h" // class HMM
+#include "hhalignment.h" // class Alignment
+#include "hhhit.h"
+#include "hhhalfalignment.h"
+#endif
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+// Methods of class FullAlignment
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Output Results: use classes HalfAlignment and FullAlignment
+//
+// Example:
+// Each column list contains at least a match state
+// Insert states between the match states are omitted
+//
+// step 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
+// i 0 0 1 2 3 4 5 6 7 8 9 9 9 9 10 11 12 13 14
+//
+// Q ~ ~ X X X X X X X X X ~ ~ ~ X X X X X
+// T Y Y Y Y Y Y Y Y ~ Y Y Y Y Y Y Y Y ~ ~
+//
+// j 7 8 9 10 11 12 13 14 14 15 16 17 18 19 20 21 22 22 22
+// state IM IM MM MM MM MM MM MM DG MM MM GD GD GD MM MM MM MI MI
+//
+// nsteps=19
+//
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Constructor
+FullAlignment::FullAlignment(int maxseqdis)
+{
+ qa = new HalfAlignment(maxseqdis);
+ ta = new HalfAlignment(maxseqdis);
+ for (int h=0; h<LINELEN-1; h++) symbol[h]=' ';
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Destructor
+FullAlignment::~FullAlignment()
+{
+ delete qa; qa = NULL;
+ delete ta; ta = NULL;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Free memory of arrays s[][], l[][], and m[][] in HalfAlignment
+void FullAlignment::FreeMemory()
+{
+ qa->Unset();
+ ta->Unset();
+}
+
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @brief Add columns for match (and delete) states.
+ */
+void
+FullAlignment::AddColumns(int i, int j, char prev_state, char state, float S)
+{
+ switch(state)
+ {
+ case MM: //MM pair state (both query and template in Match state)
+ AddGaps(); //fill up gaps until query and template parts have same length
+ symbol[qa->pos] =ScoreChr(S);
+ qa->AddColumn(i);
+ ta->AddColumn(j);
+ qa->AddInsertsAndFillUpGaps(i);
+ ta->AddInsertsAndFillUpGaps(j);
+ break;
+
+ case GD: //-D state
+ if (prev_state==DG) AddGaps();
+ symbol[ta->pos]='Q';
+ ta->AddColumn(j); //query has gap -> add nothing
+ ta->AddInsertsAndFillUpGaps(j);
+ break;
+ case IM: //IM state
+ if (prev_state==MI) AddGaps();
+ symbol[ta->pos]='Q';
+ ta->AddColumn(j); //query has gap -> add nothing
+ ta->AddInsertsAndFillUpGaps(j);
+ break;
+
+ case DG: //D- state
+ if (prev_state==GD) AddGaps();
+ symbol[qa->pos]='T';
+ qa->AddColumn(i);//template has gap -> add nothing
+ qa->AddInsertsAndFillUpGaps(i);
+ break;
+ case MI: //MI state
+ if (prev_state==IM) AddGaps();
+ symbol[qa->pos]='T';
+ qa->AddColumn(i);//template has gap -> add nothing
+ qa->AddInsertsAndFillUpGaps(i);
+ break;
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+/**
+ * @brief Fill up gaps until query and template parts have same length
+ */
+void
+FullAlignment::AddGaps()
+{
+ while (qa->pos<ta->pos) qa->AddChar('.');
+ while (ta->pos<qa->pos) ta->AddChar('.');
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @brief Build full alignment -> qa->s[k][h] and ta->s[k][h]
+ */
+int
+FullAlignment::Build(HMM& q, Hit& hit)
+{
+ int step;
+ char prev_state=MM, state=MM;
+ int n;
+ int hh;
+ int k;
+ identities=0; // number of identical residues in query and template sequence
+ score_sim=0.0f;// substitution matrix similarity score between query and template
+
+ ClearSymbols();
+
+ // Set up half-alignments
+ // n is the sequence index up to which sequences are prepared for display
+ n = imin( q.n_display,par.nseqdis+( q.nss_dssp>=0)+( q.nsa_dssp>=0)+( q.nss_pred>=0)+( q.nss_conf>=0)+( q.ncons>=0));
+ qa->Set( q.name, q.seq, q.sname, n, q.L, q.nss_dssp , q.nss_pred , q.nss_conf, q.nsa_dssp, q.ncons, hit.L/*<--FS*/);
+ n = imin(hit.n_display,par.nseqdis+(hit.nss_dssp>=0)+(hit.nsa_dssp>=0)+(hit.nss_pred>=0)+(hit.nss_conf>=0)+(hit.ncons>=0));
+ ta->Set(hit.name,hit.seq,hit.sname, n,hit.L,hit.nss_dssp,hit.nss_pred,hit.nss_conf,hit.nsa_dssp, hit.ncons, q.L/*<--FS*/);
+
+
+// printf("HMM: %s\nstep nst i j state hq ht\n",hit.name);
+
+#ifdef CLUSTALO
+ if ((1 == hit.i1) && (1 == hit.j1)){
+ /* do nothing */
+ }
+ else if ((1 == hit.i1) && (1 != hit.j1)){
+ for (int j = 1; j < hit.j1; j++){
+ AddColumns(0, j, MM, IM, 0.0);
+ }
+ if (rLog.iLogLevelEnabled <= LOG_DEBUG){
+ int iK, iL;
+ printf("%d: j1=%d -> temp has leading gaps\n", __LINE__, hit.j1);
+ for (iK = 0; iK < ta->n; iK++){
+ //printf("T%d: %s\n", iK, ta->s[iK]);
+ for (iL = 0; iL < hit.j1; iL++){
+ ta->s[iK][iL] = tolower(ta->s[iK][iL]);
+ }
+ }
+ }
+ }
+ else if ((1 != hit.i1) && (1 == hit.j1)){
+ for (int i = 1; i < hit.i1; i++){
+ AddColumns(i, 0, MM, MI, 0.0);
+ }
+ if (rLog.iLogLevelEnabled <= LOG_DEBUG){
+ FILE *fp = rLog.prFP[LOG_DEBUG];
+
+ fprintf(fp, "%d: i1=%d -> query has leading gaps\n", __LINE__, hit.i1);
+ int iK, iL;
+ for (iK = 0; iK < qa->n; iK++){
+ //printf("Q%d: %s\n", iK, qa->s[iK]);
+ for (iL = 0; iL < hit.i1; iL++){
+ qa->s[iK][iL] = tolower(qa->s[iK][iL]);
+ }
+ }
+ }
+ }
+ else {
+ fprintf(stderr,
+ "+-------------------------------+\n"
+ "| both sequences truncated left |\n"
+ "+-------------------------------+\n"
+ "i1 = %d, j1 = %d\n", hit.i1, hit.j1);
+ return FAILURE; /* FS, r241 -> r243 */
+ }
+#endif
+
+ for (step=hit.nsteps; step>=1; step--)
+ {
+ prev_state = state;
+ state = hit.states[step];
+
+ // Add column to alignment and compute identities and sequence-sequence similarity score
+ AddColumns(hit.i[step],hit.j[step],prev_state,state,hit.S[step]);
+ if (state==MM)
+ {
+ char qc=qa->seq[ q.nfirst][ qa->m[ q.nfirst][hit.i[step]] ];
+ char tc=ta->seq[hit.nfirst][ ta->m[hit.nfirst][hit.j[step]] ];
+ if (qc==tc) identities++; // count identical amino acids
+ score_sim += S[(int)aa2i(qc)][(int)aa2i(tc)];
+ // fprintf(stderr,"%3i %3i %3i %3i %3i %1c %1c %6.2f %6.2f %6.2f %6.2f \n",step,hit.nsteps,hit.i[step],hit.j[step],int(state),qc,tc,S[(int)aa2i(qc)][(int)aa2i(tc)],score_sim,hit.P_posterior[step],hit.sum_of_probs); //DEBUG
+ }
+ }
+
+#ifdef CLUSTALO
+ if ((qa->L == hit.i2) && (ta->L == hit.j2)){
+ /* do nothing */
+ }
+ else if ((qa->L == hit.i2) && (ta->L != hit.j2)){
+ for (int j = hit.j2+1; j <= ta->L; j++){
+ AddColumns(0, j, MM, IM, 0.0);
+ }
+ if (rLog.iLogLevelEnabled <= LOG_DEBUG){
+ int iK;
+ unsigned int uiL;
+ FILE *fp = rLog.prFP[LOG_DEBUG];
+
+ fprintf(fp, "%d: j2=%d (%d) -> temp has trailing gaps\n", __LINE__, hit.j2, ta->L);
+ for (iK = 0; iK < ta->n; iK++){
+ //printf("T%d: %s\n", iK, ta->s[iK]+strlen(ta->s[iK])-(ta->L-hit.j2));
+ for (uiL = strlen(ta->s[iK])-(ta->L-hit.j2); uiL < strlen(ta->s[iK]); uiL++){
+ ta->s[iK][uiL] = tolower(ta->s[iK][uiL]);
+ }
+ }
+ }
+ }
+ else if ((qa->L != hit.i2) && (ta->L == hit.j2)){
+ for (int i = hit.i2+1; i <= qa->L; i++){
+ AddColumns(i, 0, MM, MI, 0.0);
+ }
+ if (rLog.iLogLevelEnabled <= LOG_DEBUG){
+ int iK;
+ unsigned int uiL;
+ printf("%d: i2=%d (%d)-> query has trailing gaps\n", __LINE__, hit.i2, qa->L);
+ for (iK = 0; iK < qa->n; iK++){
+ //printf("Q%d: %s\n", iK, qa->s[iK]+strlen(qa->s[iK])-(qa->L-hit.i2));
+ for (uiL = strlen(qa->s[iK])-(qa->L-hit.i2); uiL < strlen(qa->s[iK]); uiL++){
+ qa->s[iK][uiL] = tolower(qa->s[iK][uiL]);
+ }
+ }
+ }
+ }
+ else{
+ fprintf(stderr,
+ "+--------------------------------+\n"
+ "| both sequences truncated right |\n"
+ "+--------------------------------+\n"
+ "i2 = %d != %d = qa->L, j2 = %d != %d = ta->L\n",
+ hit.i2, qa->L, hit.j2, ta->L);
+ return FAILURE; /* FS, r241 -> r243 */
+ }
+
+#endif
+
+ AddGaps(); //fill up gaps until query and template parts have same length
+ qa->AddChar('\0');
+ ta->AddChar('\0');
+
+ // Change gap symbol '.' (gap aligned to insert) to '~' if one HMM has gap with respect to other HMM
+ for (hh=1; hh<qa->pos; hh++)
+ {
+ if (symbol[hh]=='Q')
+ {
+ // Gap in query (IM or GD state)
+ symbol[hh]=' ';
+ for (k=0; k<qa->n; k++) if (qa->s[k][hh]=='.') qa->s[k][hh]='-';
+ }
+ else if (symbol[hh]=='T')
+ {
+ // Gap in target (MI or DG state)
+ symbol[hh]=' ';
+ for (k=0; k<ta->n; k++) if (ta->s[k][hh]=='.') ta->s[k][hh]='-';
+ }
+ }
+ return OK;
+} /* this is the end of FullAlignment::Build() */
+
+
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @brief Print out header before full alignment
+ */
+void
+FullAlignment::PrintHeader(FILE* outf, HMM& q, Hit& hit)
+{
+ fprintf(outf,">%s\n",hit.longname);
+ fprintf(outf,"Probab=%-.2f E-value=%-.2g Score=%-.2f Aligned_cols=%i Identities=%i%% Similarity=%-.3f Sum_probs=%.1f\n\n",
+ hit.Probab,hit.Eval,hit.score,hit.matched_cols,iround(100.0*identities/hit.matched_cols),score_sim/hit.matched_cols,hit.sum_of_probs);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @brief Print out full alignment in HHR format
+ */
+void
+FullAlignment::PrintHHR(FILE* outf, Hit& hit)
+{
+ const int NLEN=14; //Length of name field in front of multiple alignment
+ int h=0; //counts position (column) in alignment
+ int hh=0; //points to column at start of present output block of alignment
+ int k; //counts sequences in query and template
+ //short unsigned int lq[MAXSEQ]; // lq[k] counts index of residue from query sequence k to be printed next;
+ short unsigned int *lq = NULL; // lq[k] counts index of residue from query sequence k to be printed next;
+ //short unsigned int lt[MAXSEQ]; // lt[k] counts index of residue from template sequence k to be printed next;
+ short unsigned int *lt = NULL; // lt[k] counts index of residue from template sequence k to be printed next;
+ char namestr[NAMELEN]; //name of sequence
+ int iq=hit.i1; // match state counter for query HMM (displayed in consensus line)
+ int jt=hit.j1; // match state counter for template HMM (displayed in consensus line)
+
+ lq = new(short unsigned int[qa->n+2]);
+ lt = new(short unsigned int[ta->n+2]);
+
+ for (k=0; k<qa->n; k++) lq[k]=qa->l[k][hit.i1];
+ for (k=0; k<ta->n; k++) lt[k]=ta->l[k][hit.j1];
+
+ while (hh<ta->pos-1) // print alignment block
+ {
+ // Print query secondary structure sequences
+ for (k=0; k<qa->n; k++)
+ {
+ if (k==qa->nsa_dssp) continue;
+ if (!(k==qa->nss_dssp || k==qa->nsa_dssp || k==qa->nss_pred || k==qa->nss_conf)) continue;
+ if (k==qa->nss_dssp && !par.showdssp) continue;
+ if ((k==qa->nss_pred || k==qa->nss_conf) && !par.showpred) continue;
+ strncpy(namestr,qa->sname[k],NAMELEN-2);
+ namestr[NAMELEN-1]='\0';
+ strcut(namestr);
+ fprintf(outf,"Q %-*.*s ",NLEN,NLEN,namestr);
+ for (h=hh; h<imin(hh+par.aliwidth,qa->pos-1); h++) fprintf(outf,"%1c",qa->s[k][h]);
+ fprintf(outf,"\n");
+ }
+
+ // Print query sequences
+ for (k=0; k<qa->n; k++)
+ {
+ if (k==qa->nss_dssp || k==qa->nsa_dssp || k==qa->nss_pred || k==qa->nss_conf || k==qa->ncons) continue;
+ strncpy(namestr,qa->sname[k],NAMELEN-2);
+ namestr[NAMELEN-1]='\0';
+ strcut(namestr);
+ fprintf(outf,"Q %-*.*s %4i ",NLEN,NLEN,namestr,lq[k]);
+ for (h=hh; h<imin(hh+par.aliwidth,qa->pos-1); h++)
+ {fprintf(outf,"%1c",qa->s[k][h]); lq[k]+=WordChr(qa->s[k][h]);} //WordChr() returns 1 if a-z or A-Z; 0 otherwise
+ fprintf(outf," %4i (%i)\n",lq[k]-1,qa->l[k][qa->L+1]);
+ }
+
+ // Print query consensus sequence
+ if (par.showcons && qa->ncons>=0)
+ {
+ k=qa->ncons;
+ strncpy(namestr,qa->sname[k],NAMELEN-2);
+ namestr[NAMELEN-1]='\0';
+ strcut(namestr);
+ fprintf(outf,"Q %-*.*s %4i ",NLEN,NLEN,namestr,iq);
+ for (h=hh; h<imin(hh+par.aliwidth,qa->pos-1); h++)
+ {
+ if (qa->s[k][h]=='x') qa->s[k][h]='~';
+ if (qa->s[k][h]!='-' && qa->s[k][h]!='.') iq++;
+ fprintf(outf,"%1c",qa->s[k][h]);
+ }
+ fprintf(outf," %4i (%i)\n",iq-1,qa->L);
+ }
+
+
+ // Print symbols representing the score
+ fprintf(outf," %*.*s ",NLEN,NLEN," ");
+ for (h=hh; h<imin(hh+par.aliwidth,qa->pos-1); h++) fprintf(outf,"%1c",symbol[h]);
+ fprintf(outf,"\n");
+
+ // Print template consensus sequence
+ if (par.showcons && ta->ncons>=0)
+ {
+ k=ta->ncons;
+ strncpy(namestr,ta->sname[k],NAMELEN-2);
+ namestr[NAMELEN-1]='\0';
+ strcut(namestr);
+ fprintf(outf,"T %-*.*s %4i ",NLEN,NLEN,namestr,jt);
+ for (h=hh; h<imin(hh+par.aliwidth,ta->pos-1); h++)
+ {
+ if (ta->s[k][h]=='x') ta->s[k][h]='~';
+ if (ta->s[k][h]!='-' && ta->s[k][h]!='.') jt++;
+ fprintf(outf,"%1c",ta->s[k][h]);
+ }
+ fprintf(outf," %4i (%i)\n",jt-1,ta->L);
+ }
+ // Print template sequences
+ for (k=0; k<ta->n; k++)
+ {
+ if (k==ta->nss_dssp || k==ta->nsa_dssp || k==ta->nss_pred || k==ta->nss_conf || k==ta->ncons) continue;
+ strncpy(namestr,ta->sname[k],NAMELEN-2);
+ namestr[NAMELEN-1]='\0';
+ strcut(namestr);
+ fprintf(outf,"T %-*.*s %4i ",NLEN,NLEN,namestr,lt[k]);
+ for (h=hh; h<imin(hh+par.aliwidth,ta->pos-1); h++)
+ {fprintf(outf,"%1c",ta->s[k][h]); lt[k]+=WordChr(ta->s[k][h]);} //WordChr() returns 1 if a-z or A-Z; 0 otherwise
+ fprintf(outf," %4i (%i)\n",lt[k]-1,ta->l[k][ta->L+1]);
+ }
+
+ // Print template secondary structure sequences
+ for (k=0; k<ta->n; k++)
+ {
+ if (k==ta->nsa_dssp) continue;
+ if (!(k==ta->nss_dssp || k==ta->nss_pred || k==ta->nss_conf)) continue;
+ if (k==ta->nss_dssp && !par.showdssp) continue;
+ if ((k==ta->nss_pred || k==ta->nss_conf)&& !par.showpred) continue;
+ strncpy(namestr,ta->sname[k],NAMELEN-2);
+ namestr[NAMELEN-1]='\0';
+ strcut(namestr);
+ fprintf(outf,"T %-*.*s ",NLEN,NLEN,namestr);
+ for (h=hh; h<imin(hh+par.aliwidth,ta->pos-1); h++) fprintf(outf,"%1c",ta->s[k][h]);
+ fprintf(outf,"\n");
+ }
+
+ hh=h;
+ fprintf(outf,"\n\n");
+ }
+
+ delete[](lq); lq = NULL;
+ delete[](lt); lt = NULL;
+
+} /* this is the rnd of PrintHHR() */
+
+//////////////////////////////////////////////////////////////////////////////
+// Print out full alignment in A2M format
+//////////////////////////////////////////////////////////////////////////////
+#define TELOMER_PRINT 0
+void FullAlignment::PrintA2M(FILE* outf, Hit& hit)
+{
+ int k; //counts sequences in query and template
+ int h,hh;
+#if TELOMER_PRINT
+ int iTelomerLeft = hit.i1 - hit.j1;
+ int iTelomerRght = (qa->L - hit.i2) - (ta->L - hit.j2);
+#endif
+
+ // Print query sequences
+ for (k=0; k<qa->n; k++)
+ {
+ if (k==qa->nsa_dssp) continue;
+ if (k==qa->nss_dssp && !par.showdssp) continue;
+ if ((k==qa->nss_pred || k==qa->nss_conf) && !par.showpred) continue;
+ if (k==qa->ncons && !par.showcons) continue;
+ fprintf(outf,">%s\n",qa->sname[k]);
+#if TELOMER_PRINT
+ /* @<print left cut-off@> */
+ if (iTelomerLeft > 0){
+ for (int iI = 1; iI <= iTelomerLeft; iI++){
+ fprintf(outf, "%1c", qa->seq[k][iI]);
+ }
+ /* this may be unnecessary */
+ for (int iI = iTelomerLeft+1; iI < hit.i1; iI++){
+ fprintf(outf, "%1c", qa->seq[k][iI]);
+ }
+ }
+ else {
+ for (int iI = iTelomerLeft; iI < 0; iI++){
+ fprintf(outf, "%1c", '-');
+ }
+ /* this may be unnecessary */
+ /* think about it */
+ }
+ /* @<print consensus@> */
+ for (h = 0; qa->s[k][h] > 0; h++){
+ fprintf(outf, "%1c", qa->s[k][h]);
+ }
+ /* @<print out rght cut-off@> */
+ for (int iI = hit.i2+1; iI <= qa->L; iI++){
+ fprintf(outf, "%1c", qa->seq[k][iI]);
+ }
+ for (int iI = 0; iI > iTelomerRght; iI--){
+ fprintf(outf, "%1c", '-');
+ }
+#else
+ for (h=0,hh=-par.aliwidth; qa->s[k][h]>0; h++,hh++)
+ {
+ if (!hh) {fprintf(outf,"\n"); hh-=par.aliwidth;}
+ fprintf(outf,"%1c",qa->s[k][h]);
+ }
+#endif
+ fprintf(outf,"\n");
+ }
+
+ // Print template sequences
+ for (k=0; k<ta->n; k++)
+ {
+ if (k==ta->nsa_dssp) continue;
+ if (k==ta->nss_dssp && !par.showdssp) continue;
+ if ((k==ta->nss_pred || k==ta->nss_conf) && !par.showpred) continue;
+ if (k==ta->ncons && !par.showcons) continue;
+ fprintf(outf,">%s\n",ta->sname[k]);
+#if TELOMER_PRINT
+ /* @<print left cut-off@> */
+ if (iTelomerLeft > 0){
+ for (int iI = 1; iI <= iTelomerLeft; iI++){
+ fprintf(outf, "%1c", '-');
+ }
+ /* this may be unnecessary */
+ for (int iI = iTelomerLeft+1; iI < hit.j1; iI++){
+ fprintf(outf, "%1c", ta->seq[k][iI]);
+ }
+ }
+ else{
+ for (int iI = 1; iI <= -iTelomerLeft; iI++){
+ fprintf(outf, "%1c", ta->seq[k][iI]);
+ }
+ /* this may be unnecessary */
+ /* think about it */
+ }
+ /* @<print consensus@> */
+ for (h = 0; ta->s[k][h] > 0; h++){
+ fprintf(outf, "%1c", ta->s[k][h]);
+ }
+
+ /* @<print out rght cut-off@> */
+ for (int iI = hit.j2+1; iI <= ta->L; iI++){
+ fprintf(outf, "%1c", ta->seq[k][iI]);
+ }
+ for (int iI = 0; iI < iTelomerRght; iI++){
+ fprintf(outf, "%1c", '-');
+ }
+
+#else
+ for (h=0,hh=-par.aliwidth; ta->s[k][h]>0; h++,hh++)
+ {
+ if (!hh) {fprintf(outf,"\n"); hh-=par.aliwidth;}
+ fprintf(outf,"%1c",ta->s[k][h]);
+ }
+#endif
+ fprintf(outf,"\n");
+ }
+ fprintf(outf,"\n");
+
+} /* this is the end of PrintA2M() */
+
+////////////////////////////////////////////////////////////////////////////
+/**
+ * @brief Print out full alignment in A2M format
+ */
+void
+FullAlignment::PrintFASTA(FILE* outf, Hit& hit)
+{
+ // Transform sequences to uppercase and '.' to '-'
+ qa->ToFASTA();
+ ta->ToFASTA();
+ PrintA2M(outf,hit);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @brief Print out full alignment in A2M format
+ */
+void
+FullAlignment::PrintA3M(FILE* outf, Hit& hit)
+{
+ // Remove all '.' from sequences
+ qa->RemoveChars('.');
+ ta->RemoveChars('.');
+ PrintA2M(outf,hit);
+}
+
+
+/*
+ * @* OverWriteSeqs()
+ */
+void
+FullAlignment::OverWriteSeqs(char **ppcFirstProf, char **ppcSecndProf){
+
+ int iS, iR;
+ char cRes;
+
+ for (iS = 0; iS < qa->n; iS++){
+ for (iR = 0; iR < qa->pos; iR++){
+ cRes = qa->s[iS][iR];
+ ppcFirstProf[iS][iR] = ('.' == cRes) ? '-' : cRes;
+
+ } /* 0 <= iR < qa.L */
+ ppcFirstProf[iS][iR] = '\0';
+ } /* 0 <= iS < qa.n */
+
+ for (iS = 0; iS < ta->n; iS++){
+ for (iR = 0; iR < ta->pos; iR++){
+ cRes = ta->s[iS][iR];
+ ppcSecndProf[iS][iR] = ('.' == cRes) ? '-' : cRes;
+
+ } /* 0 <= iR < ta.L */
+ ppcSecndProf[iS][iR] = '\0';
+ } /* 0 <= iS < ta.n */
+
+} /* this is the end of OverWriteSeqs() */
+
+
git://source.jalview.org / jabaws.git / blobdiff