Interpretation of Program Output

The program, peptide-serum-stability, produces three kinds of fragment output (1) linear, (2) branched and (3) cyclic fragments. Each of the fragment output has its unique format.

For this guide, we will a cyclic peptide with a disulfide linker CGYEQDPWGVRYWYGCkkk(K-Biotin) which is represented in the program as CGYEQDPWGVRYWYGCKKKKB. The amino acids where the linker connects are emphasized.

We will represent the peptide as follows for illustrative purposes:

-	-	-	-	-	-	-	S	S	-	-	-	-	-	-	-
|															|
C	G	Y	E	Q	D	P	W	G	V	R	Y	W	Y	G	C	K	K	K	K	B

Sample output

Here is a sample output from the program using the cyclic peptide above:

The sample output will be referenced throughout the guide.

1. Linear fragments

The first suggested fragment from the sample output above, YEQDPWGVRY, corresponds to the fragment

CGYEQDPWGVRYWYGCkkk(K-Biotin)

or

-	-	-	-	-	-	-	S	S	-	-	-	-	-	-	-
|															|
C	G	Y	E	Q	D	P	W	G	V	R	Y	W	Y	G	C	K	K	K	K	B

Linear fragment outputs do not have any special characters in their fragments.

Linear fragments with linkers

For cyclic peptides, linear fragments that contain the linker are possible. For example we can have an output: WYGCSSCGYE. Notice that the linear fragment now includes amino acids from the first and second position. This linear fragment is illustrated as:

-	-	-	-	-	-	-	S	S	-	-	-	-	-	-	-
|															|
C	G	Y	E	Q	D	P	W	G	V	R	Y	W	Y	G	C	K	K	K	K	B

2. Branched Fragments

The second output from the sample output is: CG#SS#RYWYGCK

Branched fragment outputs will always have the linker surrounded by the symbol #.

To understand the output format for branched peptide, first let's look at what this output represents:

-	-	-	-	-	-	-	S	S	-	-	-	-	-	-	-
|															|
C	G	Y	E	Q	D	P	W	G	V	R	Y	W	Y	G	C	K	K	K	K	B

The current illustration of the branched fragment is difficult to print in a program due to the branching structure. Thus, we must come up with a convention to convert this branched illustration into a one line String of characters.

Let us re-arrange the branched fragment illustration such that the linker is oriented vertically and each side of the linker is on the top and the bottom horizontally:

					C	G
					|
					S
					S
					|
R	Y	W	Y	G	C	K

For the convention for this program, we replace the connection between the linker and the peptide with the # symbol. We have labeled the horizontal parts of the illustration for convenience.

(1)						C	G
						#
						S
						S
						#
(2)	R	Y	W	Y	G	C	K

Lastly, we flatten this representation into one line. It will have the following form (1)#SS#(2). In other words:

1. We first take the horizontal linear fragment (1) and write it down:

CG

2. Then take the vertical segment that contains the linker, flip it to become horizontal and append to the linear fragment (1):

CG#SS#

3. Take the horizontal linear fragment (2) and append it to the end:

CG#SS#RYWYGCK

Now we have the output we obtained from the program: CG#SS#RYWYGCK.

Another example

Let's explore another example for further clarification of the branched fragment convention.

Suppose we have the output CGYE#SS#WYGCKKKB.

The illustration for this branch as follows:

-	-	-	-	-	-	-	S	S	-	-	-	-	-	-	-
|															|
C	G	Y	E	Q	D	P	W	G	V	R	Y	W	Y	G	C	K	K	K	K	B

We re-arrange this illustration such that the linker is vertical. Then we replace the connection with the linker with # and label the horizontal linear fragments for convenience.

(1)			C	G	Y	E
			#
			S
			S
			#
(2)	W	Y	G	C	K	K	K	K	B

Then let's follow the branched fragment convention step by step.

1. We first take the horizontal linear fragment (1) and write it down:

CGYE

2. Then take the vertical segment that contains the linker, flip it to become horizontal and append to the linear fragment (1):

CGYE#SS#

3. Take the horizontal linear fragment (2) and append it to the end:

CG#SS#WYGCKKKB

Now we have the output we obtained from the program: CGYE#SS#WYGCKKKB.

3. Cyclic Fragments