void ReportTurnTypes(CHAIN **Chain, int NChain, FILE *Out, COMMAND *Cmd)
{
register int Cn, Tn;
BUFFER Bf, Tmp;
TURN *t;
Tn = 0;
for( Cn=0; Cn<NChain; Cn++ )
if( Chain[Cn]->Valid )
Tn += Chain[Cn]->NAssignedTurn;
if( !Tn ) return;
PrepareBuffer(Bf,Chain);
for( Cn=0; Cn<NChain; Cn++ ) {
if( !Chain[Cn]->Valid )
continue;
for( Tn=0; Tn<Chain[Cn]->NAssignedTurn; Tn++ ) {
t = Chain[Cn]->AssignedTurn[Tn];
sprintf(Tmp,"LOC %-11s %3s %4s %c %3s %4s %c",
Translate(t->TurnType),t->Res1,t->PDB_ResNumb1,
SpaceToDash(Chain[Cn]->Id),t->Res2,
t->PDB_ResNumb2,SpaceToDash(Chain[Cn]->Id));
Glue(Bf,Tmp,Out);
}
}
}
void ReportShort(CHAIN **Chain, int NChain, FILE *Out, COMMAND *Cmd)
{
register int Cn, i;
BUFFER Bf, Tmp;
char *Asn;
static char *StrTypes = "HGIE";
int Bound[MAX_ASSIGN][2], NStr;
if( !ExistsSecStr(Chain,NChain) )
return;
PrepareBuffer(Bf,Chain);
Glue(Bf,"REM",Out);
Glue(Bf,"REM",Out);
Glue(Bf,"REM",Out);
for( ; *StrTypes!= '\0'; StrTypes++ ) {
for( Cn=0; Cn<NChain; Cn++ ) {
if( !Chain[Cn]->Valid )
continue;
Asn = (char *)ckalloc(Chain[Cn]->NRes*sizeof(char));
ExtractAsn(Chain,Cn,Asn);
NStr = Boundaries(Asn,Chain[Cn]->NRes,(*StrTypes),Bound);
for( i=0; i<NStr; i++ ) {
sprintf(Tmp,"LOC %-10s %3s %4s %c %3s %4s %c",Translate(*StrTypes),
Chain[Cn]->Rsd[Bound[i][0]]->ResType,
Chain[Cn]->Rsd[Bound[i][0]]->PDB_ResNumb,
SpaceToDash(Chain[Cn]->Id),
Chain[Cn]->Rsd[Bound[i][1]]->ResType,
Chain[Cn]->Rsd[Bound[i][1]]->PDB_ResNumb,
SpaceToDash(Chain[Cn]->Id));
Glue(Bf,Tmp,Out);
}
free(Asn);
}
}
}
void ContactMap(CHAIN **Chain, int NChain, COMMAND *Cmd )
{
register int Res1, Res2;
int Cn1, Cn2, CA1, CA2;
float D;
for( Cn1=0; Cn1<NChain; Cn1++ ) {
if( !Chain[Cn1]->Valid )
continue;
for( Cn2=0; Cn2<NChain; Cn2++ ) {
if( !Chain[Cn2]->Valid )
continue;
for( Res1=0; Res1<Chain[Cn1]->NRes; Res1++ ) {
if( !FindAtom(Chain[Cn1],Res1,"CA",&CA1) )
continue;
for( Res2=0; Res2<Chain[Cn2]->NRes; Res2++ ) {
if( !FindAtom(Chain[Cn2],Res2,"CA",&CA2) )
continue;
D = Dist(Chain[Cn1]->Rsd[Res1]->Coord[CA1],
Chain[Cn2]->Rsd[Res2]->Coord[CA2]);
printf("%c %d <-> %c %d : %7.3f\n",
SpaceToDash(Chain[Cn1]->Id),Res1,
SpaceToDash(Chain[Cn2]->Id),Res2,D);
}
}
}
}
exit(0);
}
void ReportSSBonds(CHAIN **Chain, FILE *Out)
{
register int i;
BUFFER Bf, Tmp;
SSBOND *s;
if( !Chain[0]->NBond ) return;
PrepareBuffer(Bf,Chain);
for( i=0; i<Chain[0]->NBond; i++ ) {
s = Chain[0]->SSbond[i];
sprintf(Tmp,"LOC Disulfide CYS %4s %c CYS %4s %c ",
s->PDB_ResNumb1,SpaceToDash(s->ChainId1),
s->PDB_ResNumb2,SpaceToDash(s->ChainId2));
if( s->AsnSource == Pdb )
strcat(Tmp," PDB");
else
strcat(Tmp,"STRIDE\n");
Glue(Bf,Tmp,Out);
}
}
int Process_HELIX(BUFFER Buffer, CHAIN **Chain, int *ChainNumber, COMMAND *Cmd)
{
int CC, HC;
char *Field[MAX_FIELD];
BUFFER Tmp;
if( Cmd->NActive && !ChInStr(Cmd->Active,SpaceToDash(Buffer[19])) )
return(SUCCESS);
for( CC=0; CC < *ChainNumber && Chain[CC]->Id != Buffer[19]; CC++ );
if( CC == *ChainNumber ) {
InitChain(&Chain[CC]);
Chain[CC]->Id = Buffer[19];
(*ChainNumber)++;
}
HC = Chain[CC]->NHelix;
Chain[CC]->Helix[HC] = (HELIX *)ckalloc(sizeof(HELIX));
SplitString(Buffer+15,Field,1);
strcpy(Chain[CC]->Helix[HC]->Res1,Field[0]);
SplitString(Buffer+27,Field,1);
strcpy(Chain[CC]->Helix[HC]->Res2,Field[0]);
strcpy(Tmp,Buffer);
Tmp[25] = ' ';
Tmp[37] = ' ';
SplitString(Tmp+21,Field,1);
strcpy(Chain[CC]->Helix[HC]->PDB_ResNumb1,Field[0]);
SplitString(Tmp+33,Field,1);
strcpy(Chain[CC]->Helix[HC]->PDB_ResNumb2,Field[0]);
Chain[CC]->Helix[HC]->InsCode1 = Buffer[25];
Chain[CC]->Helix[HC]->InsCode2 = Buffer[37];
Tmp[40] = ' ';
SplitString(Tmp+38,Field,1);
Chain[CC]->Helix[HC]->Class = atoi(Field[0]);
Chain[CC]->NHelix++;
return(SUCCESS);
}
void ReportDetailed(CHAIN **Chain, int NChain, FILE *Out, COMMAND *Cmd)
{
register int i, Cn;
RESIDUE *p;
BUFFER Bf, Tmp, Tmp1;
PrepareBuffer(Bf,Chain);
Glue(Bf,"REM",Out);
sprintf(Tmp,"REM --------------- ");
strcat(Tmp,"Detailed secondary structure assignment");
strcat(Tmp,"-------------");
Glue(Bf,Tmp,Out);
Glue(Bf,"REM",Out);
Glue(Bf,"REM |---Residue---| |--Structure--| |-Phi-| |-Psi-| |-Area-| ",Out);
for( Cn=0; Cn<NChain; Cn++ ) {
if( !Chain[Cn]->Valid )
continue;
for( i=0; i<Chain[Cn]->NRes; i++ ) {
p = Chain[Cn]->Rsd[i];
sprintf(Tmp,"ASG %3s %c %4s %4d %c %11s %7.2f %7.2f %7.1f",
p->ResType,SpaceToDash(Chain[Cn]->Id),p->PDB_ResNumb,i+1,
p->Prop->Asn,Translate(p->Prop->Asn),p->Prop->Phi,
p->Prop->Psi,p->Prop->Solv);
if( Cmd->BrookhavenAsn ) {
Tmp[26] = p->Prop->PdbAsn;
Tmp[25] = ' ';
Tmp[27] = ' ';
}
if( Cmd->DsspAsn ) {
Tmp[28] = p->Prop->DsspAsn;
Tmp[27] = ' ';
Tmp[29] = ' ';
sprintf(Tmp1," %6.1f ",p->Prop->DsspSolv);
strcat(Tmp,Tmp1);
}
Glue(Bf,Tmp,Out);
}
}
}
static int Process_ATOM(BUFFER Buffer, CHAIN **Chain, int *ChainNumber,
BOOLEAN *First_ATOM, StrideCmd *Cmd) {
char *Field[MAX_FIELD];
BUFFER Tmp;
int CC, NR, NA;
static char LastRes[MAX_CHAIN][RES_FIELD];
RESIDUE *r;
if( Cmd->NActive && !ChInStr(Cmd->Active,SpaceToDash(Buffer[21])) )
return(SUCCESS);
if( Buffer[16] != 'A' && Buffer[16] != ' ' && Buffer[16] != '1' )
return(SUCCESS);
if( *First_ATOM ) {
for( CC=0; CC<MAX_CHAIN; CC++ )
strcpy(LastRes[CC],"XXXX");
*First_ATOM = NO;
}
for( CC=0; CC < *ChainNumber && Chain[CC]->Id != Buffer[21] ; CC++ );
if( CC == *ChainNumber ) {
InitChain(&Chain[CC]);
Chain[CC]->Id = Buffer[21];
(*ChainNumber)++;
}
else
if( Chain[CC]->Ter == 1 )
return(SUCCESS);
if( Buffer[34] != '.' || Buffer[42] != '.' || Buffer[50] != '.' )
return(escape(FAILURE,"File %s has no coordinates\n",Cmd->InputFile));
if( Cmd->Stringent && Buffer[63] != '.')
return(escape(FAILURE,"File %s has no temperature factor\n",Cmd->InputFile));
SplitString(Buffer+22,Field,1);
if( strcmp(Field[0],LastRes[CC]) ) {
if( strcmp(LastRes[CC],"XXXX") && !FindAtom(Chain[CC],Chain[CC]->NRes,"CA",&NA) ) {
free(Chain[CC]->Rsd[Chain[CC]->NRes]);
Chain[CC]->NRes--;
}
if( strcmp(LastRes[CC],"XXXX") ) Chain[CC]->NRes++;
NR = Chain[CC]->NRes;
strcpy(LastRes[CC],Field[0]);
Chain[CC]->Rsd[NR] = (RESIDUE *)ckalloc(sizeof(RESIDUE));
strcpy(Chain[CC]->Rsd[NR]->PDB_ResNumb,LastRes[CC]);
Chain[CC]->Rsd[NR]->NAtom = 0;
SplitString(Buffer+17,Field,1);
strcpy(Chain[CC]->Rsd[NR]->ResType,Field[0]);
}
else
NR = Chain[CC]->NRes;
NA = Chain[CC]->Rsd[NR]->NAtom;
if( Buffer[16] != ' ' ) {
strcpy(Tmp,Buffer);
Tmp[16] = ' ';
SplitString(Tmp+12,Field,1);
}
else
SplitString(Buffer+12,Field,1);
r = Chain[CC]->Rsd[NR];
strcpy(r->AtomType[NA],Field[0]);
strcpy(Tmp,Buffer);
Buffer[38] = ' ';
SplitString(Tmp+30,Field,1);
r->Coord[NA][0] = atof(Field[0]);
strcpy(Tmp,Buffer);
Buffer[46] = ' ';
SplitString(Tmp+38,Field,1);
r->Coord[NA][1] = atof(Field[0]);
strcpy(Tmp,Buffer);
Buffer[54] = ' ';
SplitString(Tmp+46,Field,1);
r->Coord[NA][2] = atof(Field[0]);
if( Buffer[57] == '.' ) {
strcpy(Tmp,Buffer);
Tmp[60] = ' ';
SplitString(Tmp+54,Field,1);
r->Occupancy[NA] = atof(Field[0]);
}
else
r->Occupancy[NA] = -1.00;
SplitString(Buffer+63,Field,1);
r->TempFactor[NA] = atof(Field[0]);
r->NAtom++;
if( r->NAtom > MAX_AT_IN_RES-1 )
return(escape(FAILURE,"File %s has too many atoms in residue %s %s %c\n",
Cmd->InputFile,r->ResType,r->PDB_ResNumb,Chain[CC]->Id));
return(SUCCESS);
}
int Process_SHEET(BUFFER Buffer, CHAIN **Chain, int *ChainNumber, COMMAND *Cmd)
{
int CC, SC, STC;
char *Field[MAX_FIELD];
BUFFER Tmp;
static char PreviousChain, PreviousSheetId[RES_FIELD];
if( Cmd->NActive && !ChInStr(Cmd->Active,SpaceToDash(Buffer[21])) )
return(SUCCESS);
for( CC=0; CC < *ChainNumber && Chain[CC]->Id != Buffer[21]; CC++ );
if( CC == *ChainNumber ) {
InitChain(&Chain[CC]);
Chain[CC]->Id = Buffer[21];
(*ChainNumber)++;
}
if( Chain[CC]->NSheet == -1 ) {
PreviousChain = '*';
strcpy(PreviousSheetId,"*");
}
SplitString(Buffer+7,Field,2);
if( atoi(Field[0]) == 1 || Buffer[21] != PreviousChain ) {
if( Buffer[21] == PreviousChain && !strcmp(PreviousSheetId,Field[1]) )
return(FAILURE);
/* die("Here it is! -> %s%c\n", Chain[CC]->File,Chain[CC]->Id);*/
Chain[CC]->NSheet++;
SC = Chain[CC]->NSheet;
Chain[CC]->Sheet[SC] = (SHEET *)ckalloc(sizeof(SHEET));
Chain[CC]->Sheet[SC]->NStrand = 0;
STC = Chain[CC]->Sheet[SC]->NStrand;
strcpy(Chain[CC]->Sheet[SC]->SheetId,Field[1]);
}
else
{
SC = Chain[CC]->NSheet;
STC = Chain[CC]->Sheet[SC]->NStrand;
}
SplitString(Buffer+17,Field,1);
strcpy(Chain[CC]->Sheet[SC]->ResType1[STC],Field[0]);
SplitString(Buffer+28,Field,1);
strcpy(Chain[CC]->Sheet[SC]->ResType2[STC],Field[0]);
strcpy(Tmp,Buffer);
Tmp[27] = ' ';
Tmp[38] = ' ';
SplitString(Tmp+22,Field,1);
strcpy(Chain[CC]->Sheet[SC]->PDB_ResNumb1[STC],Field[0]);
SplitString(Tmp+33,Field,1);
strcpy(Chain[CC]->Sheet[SC]->PDB_ResNumb2[STC],Field[0]);
Chain[CC]->Sheet[SC]->InsCode1[STC] = Buffer[26];
Chain[CC]->Sheet[SC]->InsCode2[STC] = Buffer[37];
SplitString(Buffer+38,Field,1);
Chain[CC]->Sheet[SC]->Sence[STC] = atoi(Field[0]);
if( Buffer[45] != ' ' ) {
Chain[CC]->Sheet[SC]->RegYN[STC] = 1;
SplitString(Buffer+45,Field,1);
strcpy(Chain[CC]->Sheet[SC]->ResTypeReg1[STC],Field[0]);
SplitString(Buffer+60,Field,1);
strcpy(Chain[CC]->Sheet[SC]->ResTypeReg2[STC],Field[0]);
Tmp[55] = ' ';
Tmp[70] = ' ';
SplitString(Tmp+50,Field,1);
strcpy(Chain[CC]->Sheet[SC]->PDB_ResNumbReg1[STC],Field[0]);
SplitString(Tmp+66,Field,1);
strcpy(Chain[CC]->Sheet[SC]->PDB_ResNumbReg2[STC],Field[0]);
Chain[CC]->Sheet[SC]->InsCodeReg1[STC] = Buffer[54];
Chain[CC]->Sheet[SC]->InsCodeReg2[STC] = Buffer[69];
Tmp[45] = ' ';
Tmp[60] = ' ';
SplitString(Tmp+41,Field,1);
strcpy(Chain[CC]->Sheet[SC]->AtomNameReg1[STC],Field[0]);
SplitString(Tmp+56,Field,1);
strcpy(Chain[CC]->Sheet[SC]->AtomNameReg2[STC],Field[0]);
}
else Chain[CC]->Sheet[SC]->RegYN[STC] = 0;
strcpy(PreviousSheetId,Chain[CC]->Sheet[SC]->SheetId);
PreviousChain = Buffer[21];
Chain[CC]->Sheet[SC]->NStrand++;
return(SUCCESS);
}
int CheckChain(CHAIN *Chain, StrideCmd *Cmd) {
int Res, /*HelAlp, HelPI, Hel310, Sheet, Turn,*/ Bound[300][2];
int i, j, AsnNumb=0, At, /*SuspCnt,*/ Beg, End;
/*float Content;*/
if( Cmd->NProcessed && !ChInStr(Cmd->Processed,SpaceToDash(Chain->Id)) ) {
Chain->Valid = NO;
return(FAILURE);
}
if( Chain->NRes < 5 )
return(NotValid(Chain,"less than 5 residues"));
if( !Cmd->Stringent )
return(SUCCESS);
for( Res=0; Res<Chain->NRes; Res++ ){
if( !CheckRes(Chain->Rsd[Res]->ResType) )
Chain->NonStandRes++;
for( At=0; At<Chain->Rsd[Res]->NAtom; At++) {
if( !CheckAtom(Chain->Rsd[Res]->AtomType[At]) )
Chain->NonStandAtom++;
if(Chain->Rsd[Res]->Coord[At][0] < MIN_X || Chain->Rsd[Res]->Coord[At][0] > MAX_X ||
Chain->Rsd[Res]->Coord[At][1] < MIN_Y || Chain->Rsd[Res]->Coord[At][1] > MAX_Y ||
Chain->Rsd[Res]->Coord[At][2] < MIN_Z || Chain->Rsd[Res]->Coord[At][2] > MAX_Z ||
Chain->Rsd[Res]->Occupancy[At] < MIN_Occupancy ||
Chain->Rsd[Res]->Occupancy[At] > MAX_Occupancy ||
Chain->Rsd[Res]->TempFactor[At] < MIN_TempFactor ||
Chain->Rsd[Res]->TempFactor[At] > MAX_TempFactor )
break;
}
if( At < Chain->Rsd[Res]->NAtom )
break;
}
if( Res < Chain->NRes )
return(NotValid(Chain,"suspicious coordinates, occupancy or temperature factor"));
if( 100.0*(float)Chain->NonStandRes/(float)Chain->NRes > MAXNONSTAND )
return(NotValid(Chain,"too many non-standard residues"));
if( Chain->NRes < Cmd->MinLength )
return(NotValid(Chain,"Short chain"));
if( Chain->NRes > Cmd->MaxLength )
return(NotValid(Chain,"Long chain"));
if( Chain->Method == XRay &&
(Chain->Resolution < Cmd->MinResolution || Chain->Resolution > Cmd->MaxResolution ) )
return(NotValid(Chain,"Resolution out of range"));
if( (int)strlen(Cmd->Cond) != 0 ) {
if( ChInStr(Cmd->Cond,'c') ) {
for( Res=0; Res<Chain->NRes; Res++ )
if( FindAtom(Chain,Res,"N",&At) ||
FindAtom(Chain,Res,"O",&At) ||
FindAtom(Chain,Res,"C",&At) )
break;
if( Res == Chain->NRes )
return(NotValid(Chain,"only CA"));
}
if( Chain->Method == NMR && !ChInStr(Cmd->Cond,'n') )
return(NotValid(Chain,"NMR chain"));
if( Chain->Method == XRay && !ChInStr(Cmd->Cond,'x') )
return(NotValid(Chain,"XRay chain"));
if( Chain->Method == Model && !ChInStr(Cmd->Cond,'m') )
return(NotValid(Chain,"Model chain"));
if( Chain->Published == NO && ChInStr(Cmd->Cond,'p') )
return(NotValid(Chain,"Not published"));
if( Chain->DsspAssigned == YES && ChInStr(Cmd->Cond,'d') )
return(NotValid(Chain,"Assigned according to DSSP"));
if( ChInStr(Cmd->Cond,'a') ) {
fprintf(stderr,
"WARNING: stride: CheckChain(): "
"Cmd->Cond == 'a': some functionality has been commented out");
if( Chain->Valid && Chain->NHelix == 0 && Chain->NSheet == -1 && Chain->NTurn == 0 )
return(NotValid(Chain,"No assignment"));
/* Not sure what these do but eliminating them */
/* allows removal of the Prop->PdbAsn field. */
/*
if( (Content = SecStrContent(Chain,&HelAlp,&HelPI,&Hel310,&Sheet,&Turn)) < 0.4 ||
Content > 0.9 )
return(NotValid(Chain,"Suspicious content"));
SuspCnt = 0;
for( Res=1; Res<Chain->NRes-1; Res++ ) {
if( ( Chain->Rsd[Res]->Prop->PdbAsn != 'H' && Chain->Rsd[Res]->Prop->PdbAsn != 'T' &&
Chain->Rsd[Res]->Prop->Phi > -150.0 && Chain->Rsd[Res]->Prop->Phi < 0.0 &&
Chain->Rsd[Res]->Prop->Psi > -100.0 && Chain->Rsd[Res]->Prop->Psi < 10.0) )
SuspCnt++;
}
if( (float)SuspCnt/(float)Chain->NRes > 0.4 )
return(NotValid(Chain,"Suspicious assignment"));
*/
for( i=0; i<Chain->NHelix; i++ ) {
if( !PdbN2SeqN(Chain,Chain->Helix[i]->PDB_ResNumb1,&Beg) ||
!PdbN2SeqN(Chain,Chain->Helix[i]->PDB_ResNumb2,&End) ||
/* !CheckRes(Chain->Helix[i]->PDB_ResNumb1) ||
!CheckRes(Chain->Helix[i]->PDB_ResNumb2) || */
Chain->Helix[i]->Class > 10 ||
Chain->Helix[i]->Class < 1 ||
End-Beg > 100 || End-Beg < 0 )
break;
else
if( Chain->Helix[i]->Class == 1 ) {
Bound[AsnNumb][0] = Beg;
Bound[AsnNumb][1] = End;
AsnNumb++;
}
}
if( i < Chain->NHelix )
return(NotValid(Chain,"Erraneous helix assignment"));
for( i=0; i<Chain->NSheet; i++ )
for( j=0; j<Chain->Sheet[i]->NStrand; j++ ) {
if( !PdbN2SeqN(Chain,Chain->Sheet[i]->PDB_ResNumb1[j],&Beg) ||
!PdbN2SeqN(Chain,Chain->Sheet[i]->PDB_ResNumb2[j],&End) ||
/* !CheckRes(Chain->Sheet[i]->PDB_ResNumb1[j]) ||
!CheckRes(Chain->Sheet[i]->PDB_ResNumb2[j]) || */
End-Beg > 100 || End-Beg < 0 )
break;
else
if( Chain->Sheet[i]->Sence[j] != 0 ) {
Bound[AsnNumb][0] = Beg;
Bound[AsnNumb][1] = End;
AsnNumb++;
}
if( j < Chain->Sheet[i]->NStrand )
break;
}
if( i < Chain->NSheet )
return(NotValid(Chain,"Erraneous sheet assignment"));
for( i=0; i<Chain->NTurn; i++ )
if( !PdbN2SeqN(Chain,Chain->Turn[i]->PDB_ResNumb1,&Beg) ||
!PdbN2SeqN(Chain,Chain->Turn[i]->PDB_ResNumb2,&End) ||
End-Beg > 100 || End-Beg < 0 )
break;
if( i < Chain->NTurn )
NotValid(Chain,"Erraneous turn assignment");
for( i=0; i<AsnNumb-1; i++ ) {
for( j=i+1; j<AsnNumb; j++ ) {
if( Bound[i][0] == Bound[j][0] && Bound[i][1] == Bound[j][1] ) continue;
if( (Bound[j][0] > Bound[i][0] && Bound[j][0] < Bound[i][1]) ||
(Bound[j][1] > Bound[i][0] && Bound[j][1] < Bound[i][1]) ||
(Bound[i][0] > Bound[j][0] && Bound[i][0] < Bound[j][1]) ||
(Bound[i][1] > Bound[j][0] && Bound[i][1] < Bound[j][1]) )
break;
}
if( j < AsnNumb )
break;
}
if( i < AsnNumb-1 )
return(NotValid(Chain,"Assignment overlap"));
}
}
fprintf(stderr,"ACCEPTED %s %c %4d %7.3f\n",
Chain->File,Chain->Id,Chain->NRes,Chain->Resolution);
return(SUCCESS);
}
static int NotValid(CHAIN *Chain, char *Message) {
fprintf(stderr,"IGNORED %s %c ",Chain->File,SpaceToDash(Chain->Id));
fprintf(stderr,"(%s)\n",Message);
Chain->Valid = NO;
return(FAILURE);
}
void ReportSummary(CHAIN **Chain, int NChain, FILE *Out, COMMAND *Cmd)
{
int Cn, Width, CurrWidth, NBlocks, Tail, i, j, From, To;
BUFFER Bf, Tmp, Tmp1;
PrepareBuffer(Bf,Chain);
sprintf(Tmp,"REM -------------------- ");
strcat(Tmp,"Secondary structure summary");
strcat(Tmp," -------------------");
Glue(Bf,Tmp,Out);
for( Cn=0; Cn<NChain; Cn++ ) {
if( !Chain[Cn]->Valid )
continue;
Width = 50;
Glue(Bf,"REM",Out);
strncpy(Tmp1,Chain[Cn]->File,40);
Tmp1[40] = '\0';
sprintf(Tmp,"CHN %s %c",Tmp1,SpaceToDash(Chain[Cn]->Id));
Glue(Bf,Tmp,Out);
NBlocks = Chain[Cn]->NRes/Width;
Tail = Chain[Cn]->NRes % Width;
if( Tail ) NBlocks++;
for( i=0; i<NBlocks; i++ ) {
Glue(Bf,"REM",Out);
From = i*Width;
if( i == NBlocks-1 && Tail )
CurrWidth = Tail;
else
CurrWidth = Width;
To = From+CurrWidth;
sprintf(Tmp,"REM ");
for( j=0; j<CurrWidth; j++ )
if( j && (j+1)%10 == 0 )
strcat(Tmp,".");
else
strcat(Tmp," ");
Glue(Bf,Tmp,Out);
sprintf(Tmp,"SEQ %-4d ",From+1);
for( j=From; j<From+Width; j++ ) {
if( j < To )
sprintf(Tmp1,"%c",ThreeToOne(Chain[Cn]->Rsd[j]->ResType));
else
sprintf(Tmp1," ");
strcat(Tmp,Tmp1);
}
sprintf(Tmp1," %4d",To);
strcat(Tmp,Tmp1);
Glue(Bf,Tmp,Out);
sprintf(Tmp,"STR ");
for( j=From; j<To; j++ ) {
if( Chain[Cn]->Rsd[j]->Prop->Asn == 'C' )
sprintf(Tmp1," ");
else
sprintf(Tmp1,"%c",Chain[Cn]->Rsd[j]->Prop->Asn);
strcat(Tmp,Tmp1);
}
strcat(Tmp," ");
Glue(Bf,Tmp,Out);
}
}
}
void ReportHydrBonds(CHAIN **Chain, int NChain, HBOND **HBond, FILE *Out,
COMMAND *Cmd)
{
register int i, k, Cn;
int Cnt, Res;
BUFFER Bf, Tmp, Tmp1;
HBOND *p;
RESIDUE *r;
PrepareBuffer(Bf,Chain);
Glue(Bf,"REM",Out);
sprintf(Tmp,"REM ------------------ ");
strcat(Tmp,"Mainchain hydrogen bonds");
strcat(Tmp," ------------------------");
Glue(Bf,Tmp,Out);
Glue(Bf,"REM",Out);
Glue(Bf,"REM Definition of Stickle et al., J.Mol.Biol. 226:1143-1159, 1992",Out);
Glue(Bf,"REM A1 is the angle between the planes of donor complex and O..N-C",Out);
Glue(Bf,"REM A2 is the angle between the planes of acceptor complex and N..O=C",Out);
Glue(Bf,"REM",Out);
sprintf(Tmp,"HBT %-6d",Chain[0]->NHydrBondTotal);
Glue(Bf,Tmp,Out);
sprintf(Tmp,"HBI %-6d",Chain[0]->NHydrBondInterchain);
Glue(Bf,Tmp,Out);
for( Cn=0; Cn<NChain; Cn++ )
if( Chain[Cn]->Valid ) {
sprintf(Tmp,"HBC %-6d %s %c %4d",
Chain[Cn]->NHydrBond,Chain[Cn]->File,SpaceToDash(Chain[Cn]->Id),Chain[Cn]->NRes);
Glue(Bf,Tmp,Out);
}
Glue(Bf,"REM",Out);
Glue(Bf,"REM |--Residue 1--| |--Residue 2--| N-O N..O=C O..N-C A1 A2",Out);
for( Cn=0; Cn<NChain; Cn++ ) {
if( !Chain[Cn]->Valid )
continue;
for( i=0; i<Chain[Cn]->NRes; i++ ) {
r = Chain[Cn]->Rsd[i];
Cnt = 0;
for( k=0; k<r->Inv->NBondDnr; k++ ) {
p = HBond[r->Inv->HBondDnr[k]];
if( p->ExistHydrBondRose ) {
Res = p->Acc->A_Res;
sprintf(Tmp,"DNR %4s %c %4s %4d -> ",
r->ResType,SpaceToDash(Chain[Cn]->Id),r->PDB_ResNumb,i);
sprintf(Tmp1,"%4s %c %4s %4d %4.1f %6.1f %6.1f %6.1f %6.1f ",
p->Acc->Chain->Rsd[Res]->ResType,
/* patch replace SpaceToDash(Chain[Cn]->Id), */
SpaceToDash(p->Acc->Chain->Id),
p->Acc->Chain->Rsd[Res]->PDB_ResNumb,Res,p->AccDonDist,p->AccAng,
p->DonAng,p->AccDonAng,p->DonAccAng);
strcat(Tmp,Tmp1);
Glue(Bf,Tmp,Out);
Cnt++;
}
}
Cnt = 0;
for( k=0; k<r->Inv->NBondAcc; k++ ) {
p = HBond[r->Inv->HBondAcc[k]];
if( p->ExistHydrBondRose ) {
Res = p->Dnr->D_Res;
sprintf(Tmp,"ACC %4s %c %4s %4d -> ",
r->ResType,SpaceToDash(Chain[Cn]->Id),r->PDB_ResNumb,i);
sprintf(Tmp1,"%4s %c %4s %4d %4.1f %6.1f %6.1f %6.1f %6.1f ",
p->Dnr->Chain->Rsd[Res]->ResType,
/* patch replace SpaceToDash(Chain[Cn]->Id), */
SpaceToDash(p->Dnr->Chain->Id),
p->Dnr->Chain->Rsd[Res]->PDB_ResNumb,Res,p->AccDonDist,
p->AccAng,p->DonAng,p->AccDonAng,p->DonAccAng);
strcat(Tmp,Tmp1);
Glue(Bf,Tmp,Out);
Cnt++;
}
}
}
}
}
