/**
* Adds a mutation to a {@link MutationLibrary}. Six versions of of each mutation are added to
* mutationLibrary entry. the method fill's for the given mutation all the possible vector in the
* given rotations
*
* <p>0 degrees on axis x
*
* <p>90 degrees on axis x
*
* <p>-90 degrees on axis x
*
* <p>180 degrees on axis x
*
* <p>90 degrees on axis y
*
* <p>-90 degrees on axis y
*
* @param mutation the mutation
* @param library the mutationLibrary
*/
private void addLibraryEntry(Mutation mutation, MutationLibrary library) {
Vector3f positionVector = new Vector3f();
// TODO: check for duplicity in the Dictionary while putting mutation
positionVector.sub(mutation.getLastMonomerVector(), mutation.getFirstMonomerVector());
// put in library as it is
MutationLibraryEntry newEntry =
new MutationLibraryEntry(mutation, 'x', 0, MonomerDirection.FORWARD, dimensions, matrixMan);
library.put(positionVector, newEntry);
if (dimensions == Dimensions.THREE) {
// rotation of 90 deg around x axis
addToLib(mutation, library, positionVector, (Math.PI / 2), 'x', MonomerDirection.UP);
// rotation of -90 deg around x axis
addToLib(mutation, library, positionVector, (-Math.PI / 2), 'x', MonomerDirection.DOWN);
}
// rotation of 180 deg around x axis
// TODO: check definition in here !!!
addToLib(mutation, library, positionVector, Math.PI, 'x', MonomerDirection.FORWARD);
// rotation of 90 deg around y axis
addToLib(mutation, library, positionVector, (Math.PI / 2), 'z', MonomerDirection.LEFT);
// rotation of -90 deg around y axis
addToLib(mutation, library, positionVector, (-Math.PI / 2), 'z', MonomerDirection.RIGHT);
}
private void addToLib(
Mutation mutation,
MutationLibrary library,
Vector3f positionVector,
double degree,
char axis,
MonomerDirection relative) {
if ((dimensions == Dimensions.THREE) || (relative.ordinal() < 3)) {
MutationLibraryEntry newEntry =
new MutationLibraryEntry(mutation, axis, degree, relative, dimensions, matrixMan);
library.put(matrixMan.LorentzTransformation(positionVector, axis, degree), newEntry);
}
}
/**
* @param protein - mutation will be created from this protein
* @param out - protein with low fitness. if mutation process is successful out will become the
* result of the mutation, else out will be reset.
* @param max_tries - max tries for creating a mutation.
*/
public void mutate(Protein protein, Protein out, int max_tries, int monomerIndex) {
if (protein.size() < 10)
throw new RuntimeException(
"A protein of length " + protein.size() + " Shorter than the predefined mutations");
if (protein.getConformation().size() == 0)
throw new RuntimeException("protein.conformation.size() == 0");
int nTries = 0;
boolean success = false;
int mutationLength;
int mutationStartMonomer;
int mutationLastMonomer;
Vector3f representativeVector = new Vector3f();
Vector3f start, end;
ArrayList<MutationLibraryEntry> list;
if (originalConformationIn == null) // first time here
originalConformationIn = new Conformation(protein.getConformation().size());
if (originalConformationOut == null) // first time here
originalConformationOut = new Conformation(protein.getConformation().size());
int selectedMutationIndex;
originalConformationIn.copy(protein.getConformation());
originalConformationOut.copy(out.getConformation());
if (originalConformationIn.size() == 0)
throw new RuntimeException(
"originalConformation.size() == 0 ; protein.size() = "
+ protein.size()
+ "; protein.conformation.size() = "
+ protein.getConformation().size());
MutationLibraryEntry entry;
while (nTries < max_tries) { // upon success the method will return
nTries++;
out.reset();
if (monomerIndex > 0) {
mutationLength =
random.nextInt(Math.min(protein.size() - monomerIndex, mutationLibraries.length) - 2)
+ 2;
} else {
// Generate a number between [1..protein.size-2]
mutationLength =
random.nextInt(Math.min(protein.size() - 1, mutationLibraries.length) - 2) + 2;
}
// the start monomer may be between 1 and protein size- mutation
// length
if (monomerIndex > 0) mutationStartMonomer = monomerIndex;
else mutationStartMonomer = random.nextInt(protein.size() - mutationLength - 1) + 1;
mutationLastMonomer = mutationLength + mutationStartMonomer - 1;
start = protein.get(mutationStartMonomer).getR(); // get position
// vector of start monomer.
end = protein.get(mutationLastMonomer).getR(); // get position
// vector of end monomer.
representativeVector.sub(end, start);
// if start monomer and end monomer are on a straight line no
// mutation is possible.
if (representativeVector.length() + 1 == mutationLength) continue;
mutationLibrary = mutationLibraries[mutationLength];
list = mutationLibrary.get(representativeVector);
if (list == null) // list not found for given arguments
throw new RuntimeException(
"ERROR: \nstart vector:"
+ start
+ " \nend Vector"
+ end
+ "\nsub:"
+ representativeVector
+ "\n"
+ "Mutation length:"
+ mutationLength
+ "\n"
+ "Mutation Start Monomer:"
+ mutationStartMonomer
+ "\n"
+ "Mutation Last Monomer:"
+ mutationLastMonomer
+ "\n"
+ "Protein:"
+ protein.toString());
if (list.size() > 0) {
/* Filter mutations - save only valid mutations */
// collect position of the protein before and after the
// mutation.
// save them not as absolut position but as offset from the star
// of mutation, this
// helps us compare them to the position needed by the mutation.
proteinPositions.clear();
for (int i = 0; i < protein.size(); i++) {
if ((i < mutationStartMonomer || i > mutationLastMonomer)) {
// TODO: avoid creating a new vector.
Vector3f vec = new Vector3f(protein.get(i).getR());
vec.sub(start); // Save position as an offset from start
// of mutation.
proteinPositions.add(vec);
}
}
// Save in candidates only the mutations that do no overlap with
// already occupied position of the protein.
// (the position collected in the previous loop)
candidates.clear();
for (MutationLibraryEntry lib : list) {
boolean found = false;
for (Vector3f vec : lib.positionOffsets) {
if ((found = proteinPositions.contains(vec))) break;
}
if (!found) candidates.add(lib);
}
if (candidates.isEmpty()) // if no candidates try new mutation.
continue;
// Select random mutation from candidates.
selectedMutationIndex = selectMutationNumber(candidates);
entry = candidates.get(selectedMutationIndex);
success =
activateMutationOnProtein(
out,
protein,
entry,
mutationStartMonomer,
mutationLastMonomer,
originalConformationIn);
}
if (success) return;
}
out.reset();
out.setConformation(originalConformationOut);
}
