def generate_axis_system(sim_index=None):
"""Generate and return the full 3D axis system for the current frame order model.
@keyword sim_index: The optional MC simulation index to obtain the frame for a given simulation.
@type sim_index: None or int
@return: The full 3D axis system for the model.
@rtype: numpy rank-2, 3D float64 array
"""
# Initialise.
axis = zeros(3, float64)
frame = zeros((3, 3), float64)
# The 1st pivot point.
pivot = generate_pivot(order=1, sim_index=sim_index, pdb_limit=True)
# The CoM of the system.
com = pipe_centre_of_mass(verbosity=0, missing_error=False)
# The system for the rotor models.
if cdp.model in [MODEL_ROTOR, MODEL_FREE_ROTOR]:
# Generate the axis.
if sim_index == None:
axis = create_rotor_axis_alpha(alpha=cdp.axis_alpha, pivot=pivot, point=com)
else:
axis = create_rotor_axis_alpha(alpha=cdp.axis_alpha_sim[sim_index], pivot=pivot, point=com)
# Create a full normalised axis system.
frame_from_axis(axis, frame)
# The system for the isotropic cones.
elif cdp.model in MODEL_LIST_ISO_CONE:
# Generate the axis.
if sim_index == None:
axis = create_rotor_axis_spherical(theta=cdp.axis_theta, phi=cdp.axis_phi)
else:
axis = create_rotor_axis_spherical(theta=cdp.axis_theta_sim[sim_index], phi=cdp.axis_phi_sim[sim_index])
# Create a full normalised axis system.
frame_from_axis(axis, frame)
# The system for the pseudo-ellipses and double rotor.
elif cdp.model in MODEL_LIST_PSEUDO_ELLIPSE + MODEL_LIST_DOUBLE:
# Generate the eigenframe of the motion.
if sim_index == None:
euler_to_R_zyz(cdp.eigen_alpha, cdp.eigen_beta, cdp.eigen_gamma, frame)
else:
euler_to_R_zyz(cdp.eigen_alpha_sim[sim_index], cdp.eigen_beta_sim[sim_index], cdp.eigen_gamma_sim[sim_index], frame)
# Unknown model.
else:
raise RelaxFault
# Return the full eigenframe.
return frame
def average_position(structure=None, models=None, sim=None):
"""Shift the given structural object to the average position.
@keyword structure: The structural object to operate on.
@type structure: lib.structure.internal.object.Internal instance
@keyword models: The list of models to shift.
@type models: list of int
@keyword sim: A flag which if True will use the Monte Carlo simulation results. In this case, the model list should be set to the simulation indices plus 1 and the structural object should have one model per simulation already set up.
@type sim: bool
"""
# The selection object.
selection = structure.selection(atom_id=domain_moving())
# Loop over each model.
for i in range(len(models)):
# First rotate the moving domain to the average position.
R = zeros((3, 3), float64)
if hasattr(cdp, 'ave_pos_alpha'):
if sim:
euler_to_R_zyz(cdp.ave_pos_alpha_sim[i],
cdp.ave_pos_beta_sim[i],
cdp.ave_pos_gamma_sim[i], R)
else:
euler_to_R_zyz(cdp.ave_pos_alpha, cdp.ave_pos_beta,
cdp.ave_pos_gamma, R)
else:
if sim:
euler_to_R_zyz(0.0, cdp.ave_pos_beta_sim[i],
cdp.ave_pos_gamma_sim[i], R)
else:
euler_to_R_zyz(0.0, cdp.ave_pos_beta, cdp.ave_pos_gamma, R)
origin = pipe_centre_of_mass(atom_id=domain_moving(),
verbosity=0,
missing_error=False)
structure.rotate(R=R,
origin=origin,
model=models[i],
selection=selection)
# Then translate the moving domain.
if sim:
T = [
cdp.ave_pos_x_sim[i], cdp.ave_pos_y_sim[i],
cdp.ave_pos_z_sim[i]
]
else:
T = [cdp.ave_pos_x, cdp.ave_pos_y, cdp.ave_pos_z]
structure.translate(T=T, model=models[i], selection=selection)
def average_position(structure=None, models=None, sim=None):
"""Shift the given structural object to the average position.
@keyword structure: The structural object to operate on.
@type structure: lib.structure.internal.object.Internal instance
@keyword models: The list of models to shift.
@type models: list of int
@keyword sim: A flag which if True will use the Monte Carlo simulation results. In this case, the model list should be set to the simulation indices plus 1 and the structural object should have one model per simulation already set up.
@type sim: bool
"""
# The selection object.
selection = structure.selection(atom_id=domain_moving())
# Loop over each model.
for i in range(len(models)):
# First rotate the moving domain to the average position.
R = zeros((3, 3), float64)
if hasattr(cdp, 'ave_pos_alpha'):
if sim:
euler_to_R_zyz(cdp.ave_pos_alpha_sim[i], cdp.ave_pos_beta_sim[i], cdp.ave_pos_gamma_sim[i], R)
else:
euler_to_R_zyz(cdp.ave_pos_alpha, cdp.ave_pos_beta, cdp.ave_pos_gamma, R)
else:
if sim:
euler_to_R_zyz(0.0, cdp.ave_pos_beta_sim[i], cdp.ave_pos_gamma_sim[i], R)
else:
euler_to_R_zyz(0.0, cdp.ave_pos_beta, cdp.ave_pos_gamma, R)
origin = pipe_centre_of_mass(atom_id=domain_moving(), verbosity=0, missing_error=False)
structure.rotate(R=R, origin=origin, model=models[i], selection=selection)
# Then translate the moving domain.
if sim:
T = [cdp.ave_pos_x_sim[i], cdp.ave_pos_y_sim[i], cdp.ave_pos_z_sim[i]]
else:
T = [cdp.ave_pos_x, cdp.ave_pos_y, cdp.ave_pos_z]
structure.translate(T=T, model=models[i], selection=selection)
# Set the domain info.
align_tensor.set_domain(tensor=full[i], domain='N')
align_tensor.set_domain(tensor=red[i], domain='C')
# Specify which tensor is reduced.
align_tensor.reduction(full_tensor=full[i], red_tensor=red[i])
# Select the model.
frame_order.select_model('rotor')
# Set the reference domain.
frame_order.ref_domain('N')
# Set the initial pivot point.
pivot = shift_pivot(pivot_orig=array([ 37.254, 0.5, 16.7465]), com=pipe_centre_of_mass(verbosity=0), axis=AXIS)
frame_order.pivot(pivot, fix=True)
# Set the paramagnetic centre.
paramag.centre(pos=[35.934, 12.194, -4.206])
# Check the minimum (at a very high quality to check that the chi-squared value is zero).
frame_order.num_int_pts(num=100000)
value.set(param='ave_pos_x', val=AVE_POS_X)
value.set(param='ave_pos_y', val=AVE_POS_Y)
value.set(param='ave_pos_z', val=AVE_POS_Z)
value.set(param='ave_pos_alpha', val=AVE_POS_ALPHA)
value.set(param='ave_pos_beta', val=AVE_POS_BETA)
value.set(param='ave_pos_gamma', val=AVE_POS_GAMMA)
value.set(param='axis_alpha', val=alpha_angle(pivot=pivot, com=pipe_centre_of_mass(verbosity=0), axis=AXIS))
value.set(param='cone_sigma_max', val=CONE_SIGMA_MAX)
# Set the domain info.
align_tensor.set_domain(tensor=full[i], domain='N')
align_tensor.set_domain(tensor=red[i], domain='C')
# Specify which tensor is reduced.
align_tensor.reduction(full_tensor=full[i], red_tensor=red[i])
# Select the model.
frame_order.select_model('rotor')
# Set the reference domain.
frame_order.ref_domain('N')
# Set the initial pivot point.
pivot = shift_pivot(pivot_orig=array([ 37.254, 0.5, 16.7465]), com=pipe_centre_of_mass(verbosity=0), axis=AXIS)
frame_order.pivot(pivot, fix=True)
# Set the paramagnetic centre.
paramag.centre(pos=[35.934, 12.194, -4.206])
# Check the minimum (at a very high quality to check that the chi-squared value is zero).
frame_order.num_int_pts(num=100000)
frame_order.quad_int(flag=False)
value.set(param='ave_pos_x', val=AVE_POS_X)
value.set(param='ave_pos_y', val=AVE_POS_Y)
value.set(param='ave_pos_z', val=AVE_POS_Z)
value.set(param='ave_pos_alpha', val=AVE_POS_ALPHA)
value.set(param='ave_pos_beta', val=AVE_POS_BETA)
value.set(param='ave_pos_gamma', val=AVE_POS_GAMMA)
value.set(param='axis_alpha', val=alpha_angle(pivot=pivot, com=pipe_centre_of_mass(verbosity=0), axis=AXIS))
# Set the domain info.
align_tensor.set_domain(tensor=full[i], domain='N')
align_tensor.set_domain(tensor=red[i], domain='C')
# Specify which tensor is reduced.
align_tensor.reduction(full_tensor=full[i], red_tensor=red[i])
# Select the model.
frame_order.select_model('free rotor')
# Set the reference domain.
frame_order.ref_domain('N')
# Set the initial pivot point.
pivot = shift_pivot(pivot_orig=array([37.254, 0.5, 16.7465]),
com=pipe_centre_of_mass(verbosity=0),
axis=AXIS)
frame_order.pivot(pivot, fix=True)
# Set the paramagnetic centre.
paramag.centre(pos=[35.934, 12.194, -4.206])
# Check the minimum (at a very high quality to check that the chi-squared value is zero).
frame_order.num_int_pts(num=100000)
value.set(param='ave_pos_x', val=AVE_POS_X)
value.set(param='ave_pos_y', val=AVE_POS_Y)
value.set(param='ave_pos_z', val=AVE_POS_Z)
value.set(param='ave_pos_beta', val=AVE_POS_BETA)
value.set(param='ave_pos_gamma', val=AVE_POS_GAMMA)
value.set(param='axis_alpha',
val=alpha_angle(pivot=pivot,
def create_diff_tensor_pdb(scale=1.8e-6, file=None, dir=None, force=False):
"""Create the PDB representation of the diffusion tensor.
@keyword scale: The scaling factor for the diffusion tensor.
@type scale: float
@keyword file: The name of the PDB file to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword force: Flag which if set to True will overwrite any pre-existing file.
@type force: bool
"""
# Test if the current data pipe exists.
pipes.test()
# Calculate the centre of mass.
com = pipe_centre_of_mass()
# Create the structural object.
structure = Internal()
# Create an array of data pipes to loop over (hybrid support).
if cdp.pipe_type == 'hybrid':
pipe_list = cdp.hybrid_pipes
else:
pipe_list = [pipes.cdp_name()]
# The molecule names.
if cdp.pipe_type == 'hybrid':
mol_names = []
for pipe in pipe_list:
mol_names.append('diff_tensor_' % pipe)
else:
mol_names = ['diff_tensor']
# Loop over the pipes.
for pipe_index in range(len(pipe_list)):
# Get the pipe container.
pipe = pipes.get_pipe(pipe_list[pipe_index])
# Test if the diffusion tensor data is loaded.
if not hasattr(pipe, 'diff_tensor'):
raise RelaxNoTensorError('diffusion')
# Test if a structure has been loaded.
if not hasattr(cdp, 'structure'):
raise RelaxNoPdbError
# Add a new structure.
structure.add_molecule(name=mol_names[pipe_index])
# Alias the single molecule from the single model.
mol = structure.get_molecule(mol_names[pipe_index])
# The diffusion tensor type.
diff_type = pipe.diff_tensor.type
if diff_type == 'spheroid':
diff_type = pipe.diff_tensor.spheroid_type
# Simulation info.
sim_num = None
if hasattr(pipe.diff_tensor, 'tm_sim'):
# The number.
sim_num = len(pipe.diff_tensor.tm_sim)
# Tensor axes.
axes = []
sim_axes = []
if diff_type in ['oblate', 'prolate']:
axes.append(pipe.diff_tensor.Dpar * pipe.diff_tensor.Dpar_unit)
if sim_num != None:
sim_axes.append([])
for i in range(sim_num):
sim_axes[0].append(pipe.diff_tensor.Dpar_sim[i] * pipe.diff_tensor.Dpar_unit_sim[i])
if diff_type == 'ellipsoid':
axes.append(pipe.diff_tensor.Dx * pipe.diff_tensor.Dx_unit)
axes.append(pipe.diff_tensor.Dy * pipe.diff_tensor.Dy_unit)
axes.append(pipe.diff_tensor.Dz * pipe.diff_tensor.Dz_unit)
if sim_num != None:
sim_axes.append([])
sim_axes.append([])
sim_axes.append([])
for i in range(sim_num):
sim_axes[0].append(pipe.diff_tensor.Dx_sim[i] * pipe.diff_tensor.Dx_unit_sim[i])
sim_axes[1].append(pipe.diff_tensor.Dy_sim[i] * pipe.diff_tensor.Dy_unit_sim[i])
sim_axes[2].append(pipe.diff_tensor.Dz_sim[i] * pipe.diff_tensor.Dz_unit_sim[i])
# Create the object.
diffusion_tensor(mol=mol, tensor=pipe.diff_tensor.tensor, tensor_diag=pipe.diff_tensor.tensor_diag, diff_type=diff_type, rotation=pipe.diff_tensor.rotation, axes=axes, sim_axes=sim_axes, com=com, scale=scale)
# Create the PDB file.
######################
# Print out.
print("\nGenerating the PDB file.")
# Create the PDB file.
tensor_pdb_file = open_write_file(file, dir, force=force)
structure.write_pdb(tensor_pdb_file)
tensor_pdb_file.close()
# Add the file to the results file list.
if not hasattr(cdp, 'result_files'):
cdp.result_files = []
if dir == None:
dir = getcwd()
cdp.result_files.append(['diff_tensor_pdb', 'Diffusion tensor PDB', get_file_path(file, dir)])
status.observers.result_file.notify()
def create_vector_dist(length=None, symmetry=True, file=None, dir=None, force=False):
"""Create a PDB representation of the vector distribution.
@keyword length: The length to set the vectors to in the PDB file.
@type length: float
@keyword symmetry: The symmetry flag which if set will create a second PDB chain 'B' which is the same as chain 'A' but with the vectors reversed.
@type symmetry: bool
@keyword file: The name of the PDB file to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword force: Flag which if set will overwrite any pre-existing file.
@type force: bool
"""
# Test if the current pipe exists.
pipes.test()
# Test if a structure has been loaded.
if not hasattr(cdp, 'structure') or not cdp.structure.num_models() > 0:
raise RelaxNoPdbError
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if unit vectors exist.
vectors = False
for interatom in interatomic_loop():
if hasattr(interatom, 'vector'):
vectors = True
break
if not vectors:
raise RelaxNoVectorsError
# Initialise.
#############
# Create the structural object.
structure = Internal()
# Add a structure.
structure.add_molecule(name='vector_dist')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Initialise the residue and atom numbers.
res_num = 1
atom_num = 1
# Centre of mass.
#################
# Calculate the centre of mass.
R = pipe_centre_of_mass()
# Increment the residue number.
res_num = res_num + 1
# The vectors.
##############
# Loop over the interatomic data containers.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(interatom.spin_id1)
spin2 = return_spin(interatom.spin_id2)
# Skip deselected spin systems.
if not spin1.select or not spin2.select:
continue
# Skip containers missing vectors.
if not hasattr(interatom, 'vector'):
continue
# Scale the vector.
vector = interatom.vector * length * 1e10
# Add the first spin as the central atom.
mol.atom_add(pdb_record='ATOM', atom_num=atom_num, atom_name=spin1.name, res_name=spin1._res_name, chain_id='A', res_num=spin1._res_num, pos=R, segment_id=None, element=spin1.element)
# Add the second spin as the end atom.
mol.atom_add(pdb_record='ATOM', atom_num=atom_num+1, atom_name=spin2.name, res_name=spin2._res_name, chain_id='A', res_num=spin2._res_num, pos=R+vector, segment_id=None, element=spin2.element)
# Connect the two atoms.
mol.atom_connect(index1=atom_num-1, index2=atom_num)
# Increment the atom number.
atom_num = atom_num + 2
# Symmetry chain.
if symmetry:
# Loop over the interatomic data containers.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(interatom.spin_id1)
spin2 = return_spin(interatom.spin_id2)
# Skip deselected spin systems.
if not spin1.select or not spin2.select:
continue
# Skip containers missing vectors.
if not hasattr(interatom, 'vector'):
continue
# Scale the vector.
vector = interatom.vector * length * 1e10
# Add the first spin as the central atom.
mol.atom_add(pdb_record='ATOM', atom_num=atom_num, atom_name=spin1.name, res_name=spin1._res_name, chain_id='B', res_num=spin1._res_num, pos=R, segment_id=None, element=spin1.element)
# Add the second spin as the end atom.
mol.atom_add(pdb_record='ATOM', atom_num=atom_num+1, atom_name=spin2.name, res_name=spin2._res_name, chain_id='B', res_num=spin2._res_num, pos=R-vector, segment_id=None, element=spin2.element)
# Connect the two atoms.
mol.atom_connect(index1=atom_num-1, index2=atom_num)
# Increment the atom number.
atom_num = atom_num + 2
# Create the PDB file.
######################
# Print out.
print("\nGenerating the PDB file.")
# Open the PDB file for writing.
tensor_pdb_file = open_write_file(file, dir, force=force)
# Write the data.
structure.write_pdb(tensor_pdb_file)
# Close the file.
tensor_pdb_file.close()
# Add the file to the results file list.
if not hasattr(cdp, 'result_files'):
cdp.result_files = []
if dir == None:
dir = getcwd()
cdp.result_files.append(['vector_dist_pdb', 'Vector distribution PDB', get_file_path(file, dir)])
status.observers.result_file.notify()
def create_vector_dist(length=None,
symmetry=True,
file=None,
dir=None,
force=False):
"""Create a PDB representation of the vector distribution.
@keyword length: The length to set the vectors to in the PDB file.
@type length: float
@keyword symmetry: The symmetry flag which if set will create a second PDB chain 'B' which is the same as chain 'A' but with the vectors reversed.
@type symmetry: bool
@keyword file: The name of the PDB file to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword force: Flag which if set will overwrite any pre-existing file.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if a structure has been loaded.
if not hasattr(cdp, 'structure') or not cdp.structure.num_models() > 0:
raise RelaxNoPdbError
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if unit vectors exist.
vectors = False
for interatom in interatomic_loop():
if hasattr(interatom, 'vector'):
vectors = True
break
if not vectors:
raise RelaxNoVectorsError
# Initialise.
#############
# Create the structural object.
structure = Internal()
# Add a structure.
structure.add_molecule(name='vector_dist')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Initialise the residue and atom numbers.
res_num = 1
atom_num = 1
# Centre of mass.
#################
# Calculate the centre of mass.
R = pipe_centre_of_mass()
# Increment the residue number.
res_num = res_num + 1
# The vectors.
##############
# Loop over the interatomic data containers.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(spin_hash=interatom._spin_hash1)
spin2 = return_spin(spin_hash=interatom._spin_hash2)
# Skip deselected spin systems.
if not spin1.select or not spin2.select:
continue
# Skip containers missing vectors.
if not hasattr(interatom, 'vector'):
continue
# Scale the vector.
vector = interatom.vector * length * 1e10
# Add the first spin as the central atom.
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num,
atom_name=spin1.name,
res_name=spin1._res_name,
chain_id='A',
res_num=spin1._res_num,
pos=R,
segment_id=None,
element=spin1.element)
# Add the second spin as the end atom.
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num + 1,
atom_name=spin2.name,
res_name=spin2._res_name,
chain_id='A',
res_num=spin2._res_num,
pos=R + vector,
segment_id=None,
element=spin2.element)
# Connect the two atoms.
mol.atom_connect(index1=atom_num - 1, index2=atom_num)
# Increment the atom number.
atom_num = atom_num + 2
# Symmetry chain.
if symmetry:
# Loop over the interatomic data containers.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(spin_hash=interatom._spin_hash1)
spin2 = return_spin(spin_hash=interatom._spin_hash2)
# Skip deselected spin systems.
if not spin1.select or not spin2.select:
continue
# Skip containers missing vectors.
if not hasattr(interatom, 'vector'):
continue
# Scale the vector.
vector = interatom.vector * length * 1e10
# Add the first spin as the central atom.
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num,
atom_name=spin1.name,
res_name=spin1._res_name,
chain_id='B',
res_num=spin1._res_num,
pos=R,
segment_id=None,
element=spin1.element)
# Add the second spin as the end atom.
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num + 1,
atom_name=spin2.name,
res_name=spin2._res_name,
chain_id='B',
res_num=spin2._res_num,
pos=R - vector,
segment_id=None,
element=spin2.element)
# Connect the two atoms.
mol.atom_connect(index1=atom_num - 1, index2=atom_num)
# Increment the atom number.
atom_num = atom_num + 2
# Create the PDB file.
######################
# Print out.
print("\nGenerating the PDB file.")
# Open the PDB file for writing.
tensor_pdb_file = open_write_file(file, dir, force=force)
# Write the data.
structure.write_pdb(tensor_pdb_file)
# Close the file.
tensor_pdb_file.close()
# Add the file to the results file list.
if not hasattr(cdp, 'result_files'):
cdp.result_files = []
if dir == None:
dir = getcwd()
cdp.result_files.append([
'vector_dist_pdb', 'Vector distribution PDB',
get_file_path(file, dir)
])
status.observers.result_file.notify()
def add_rotors(structure=None, representation=None, size=None, sims=False):
"""Add all rotor objects for the current frame order model to the structural object.
@keyword structure: The internal structural object to add the rotor objects to.
@type structure: lib.structure.internal.object.Internal instance
@keyword representation: The representation to create. If this is set to None, the rotor will be dumbbell shaped with propellers at both ends. If set to 'A' or 'B', only half of the rotor will be shown.
@type representation: None or str
@keyword size: The size of the geometric object in Angstroms.
@type size: float
@keyword sims: A flag which if True will add the Monte Carlo simulation rotors to the structural object. There must be one model for each Monte Carlo simulation already present in the structural object.
@type sims: bool
"""
# Initialise the list structures for the rotor data.
axis = []
span = []
staggered = []
pivot = []
rotor_angle = []
com = []
label = []
models = []
# The half-rotor flag.
half_rotor = True
if representation == None:
half_rotor = False
# The transformation matrix (identity matrix or inversion matrix).
if representation == 'B':
T = -eye(3)
else:
T = eye(3)
# The models to loop over.
model_nums = [None]
sim_indices = [None]
if sims:
model_nums = [i+1 for i in range(cdp.sim_number)]
sim_indices = list(range(cdp.sim_number))
# Loop over the models.
for i in range(len(model_nums)):
# The pivot points.
pivot1 = generate_pivot(order=1, sim_index=sim_indices[i], pdb_limit=True)
pivot2 = generate_pivot(order=2, sim_index=sim_indices[i], pdb_limit=True)
# The single rotor models.
if cdp.model in [MODEL_ROTOR, MODEL_FREE_ROTOR, MODEL_ISO_CONE, MODEL_ISO_CONE_FREE_ROTOR, MODEL_PSEUDO_ELLIPSE, MODEL_PSEUDO_ELLIPSE_FREE_ROTOR]:
# The rotor angle.
if cdp.model in MODEL_LIST_FREE_ROTORS:
rotor_angle.append(pi)
else:
if sims:
rotor_angle.append(cdp.cone_sigma_max_sim[sim_indices[i]])
else:
rotor_angle.append(cdp.cone_sigma_max)
# Get the CoM of the entire molecule to use as the centre of the rotor.
if cdp.model in [MODEL_ROTOR, MODEL_FREE_ROTOR]:
com.append(pipe_centre_of_mass(verbosity=0, missing_error=False))
else:
com.append(pivot1)
# Generate the rotor axis.
axes = generate_axis_system(sim_index=sim_indices[i])
axis.append(axes[:, 2])
# The size of the rotor (Angstrom), taking the cone representation into account by adding 5 Angstrom.
if cdp.model in [MODEL_ROTOR, MODEL_FREE_ROTOR]:
span.append(size)
else:
span.append(size + 5.0)
# Stagger the propeller blades.
if cdp.model in MODEL_LIST_FREE_ROTORS:
staggered.append(False)
else:
staggered.append(True)
# The pivot.
pivot.append(pivot1)
# The label.
label.append('z-ax')
# The models.
if sims:
models.append(model_nums[i])
else:
models.append(None)
# The double rotor models.
elif cdp.model in [MODEL_DOUBLE_ROTOR]:
# Add both rotor angles (the 2nd must come first).
if sims:
rotor_angle.append(cdp.cone_sigma_max_2_sim[sim_indices[i]])
rotor_angle.append(cdp.cone_sigma_max_sim[sim_indices[i]])
else:
rotor_angle.append(cdp.cone_sigma_max_2)
rotor_angle.append(cdp.cone_sigma_max)
# Set the com to the pivot points.
com.append(pivot2)
com.append(pivot1)
# Generate the eigenframe of the motion.
frame = generate_axis_system(sim_index=sim_indices[i])
# Add the x and y axes.
axis.append(frame[:, 0])
axis.append(frame[:, 1])
# The rotor size (Angstrom).
span.append(size)
span.append(size)
# Stagger the propeller blades.
staggered.append(True)
staggered.append(True)
# The pivot points.
pivot.append(pivot2)
pivot.append(pivot1)
# The labels.
label.append('x-ax')
label.append('y-ax')
# The models.
if sims:
models.append(model_nums[i])
models.append(model_nums[i])
else:
models.append(None)
models.append(None)
# Add each rotor to the structure as a new molecule.
for i in range(len(axis)):
rotor(structure=structure, rotor_angle=rotor_angle[i], axis=dot(T, axis[i]), axis_pt=pivot[i], label=label[i], centre=com[i], span=span[i]/1e10, blade_length=5e-10, model_num=models[i], staggered=staggered[i], half_rotor=half_rotor)
def generate_axis_system(sim_index=None):
"""Generate and return the full 3D axis system for the current frame order model.
@keyword sim_index: The optional MC simulation index to obtain the frame for a given simulation.
@type sim_index: None or int
@return: The full 3D axis system for the model.
@rtype: numpy rank-2, 3D float64 array
"""
# Initialise.
axis = zeros(3, float64)
frame = zeros((3, 3), float64)
# The 1st pivot point.
pivot = generate_pivot(order=1, sim_index=sim_index, pdb_limit=True)
# The CoM of the system.
com = pipe_centre_of_mass(verbosity=0, missing_error=False)
# The system for the rotor models.
if cdp.model in [MODEL_ROTOR, MODEL_FREE_ROTOR]:
# Generate the axis.
if sim_index == None:
axis = create_rotor_axis_alpha(alpha=cdp.axis_alpha,
pivot=pivot,
point=com)
else:
axis = create_rotor_axis_alpha(alpha=cdp.axis_alpha_sim[sim_index],
pivot=pivot,
point=com)
# Create a full normalised axis system.
frame_from_axis(axis, frame)
# The system for the isotropic cones.
elif cdp.model in MODEL_LIST_ISO_CONE:
# Generate the axis.
if sim_index == None:
axis = create_rotor_axis_spherical(theta=cdp.axis_theta,
phi=cdp.axis_phi)
else:
axis = create_rotor_axis_spherical(
theta=cdp.axis_theta_sim[sim_index],
phi=cdp.axis_phi_sim[sim_index])
# Create a full normalised axis system.
frame_from_axis(axis, frame)
# The system for the pseudo-ellipses and double rotor.
elif cdp.model in MODEL_LIST_PSEUDO_ELLIPSE + MODEL_LIST_DOUBLE:
# Generate the eigenframe of the motion.
if sim_index == None:
euler_to_R_zyz(cdp.eigen_alpha, cdp.eigen_beta, cdp.eigen_gamma,
frame)
else:
euler_to_R_zyz(cdp.eigen_alpha_sim[sim_index],
cdp.eigen_beta_sim[sim_index],
cdp.eigen_gamma_sim[sim_index], frame)
# Unknown model.
else:
raise RelaxFault
# Return the full eigenframe.
return frame
def add_rotors(structure=None, representation=None, size=None, sims=False):
"""Add all rotor objects for the current frame order model to the structural object.
@keyword structure: The internal structural object to add the rotor objects to.
@type structure: lib.structure.internal.object.Internal instance
@keyword representation: The representation to create. If this is set to None, the rotor will be dumbbell shaped with propellers at both ends. If set to 'A' or 'B', only half of the rotor will be shown.
@type representation: None or str
@keyword size: The size of the geometric object in Angstroms.
@type size: float
@keyword sims: A flag which if True will add the Monte Carlo simulation rotors to the structural object. There must be one model for each Monte Carlo simulation already present in the structural object.
@type sims: bool
"""
# Initialise the list structures for the rotor data.
axis = []
span = []
staggered = []
pivot = []
rotor_angle = []
com = []
label = []
models = []
# The half-rotor flag.
half_rotor = True
if representation == None:
half_rotor = False
# The transformation matrix (identity matrix or inversion matrix).
if representation == 'B':
T = -eye(3)
else:
T = eye(3)
# The models to loop over.
model_nums = [None]
sim_indices = [None]
if sims:
model_nums = [i + 1 for i in range(cdp.sim_number)]
sim_indices = list(range(cdp.sim_number))
# Loop over the models.
for i in range(len(model_nums)):
# The pivot points.
pivot1 = generate_pivot(order=1,
sim_index=sim_indices[i],
pdb_limit=True)
pivot2 = generate_pivot(order=2,
sim_index=sim_indices[i],
pdb_limit=True)
# The single rotor models.
if cdp.model in [
MODEL_ROTOR, MODEL_FREE_ROTOR, MODEL_ISO_CONE,
MODEL_ISO_CONE_FREE_ROTOR, MODEL_PSEUDO_ELLIPSE,
MODEL_PSEUDO_ELLIPSE_FREE_ROTOR
]:
# The rotor angle.
if cdp.model in MODEL_LIST_FREE_ROTORS:
rotor_angle.append(pi)
else:
if sims:
rotor_angle.append(cdp.cone_sigma_max_sim[sim_indices[i]])
else:
rotor_angle.append(cdp.cone_sigma_max)
# Get the CoM of the entire molecule to use as the centre of the rotor.
if cdp.model in [MODEL_ROTOR, MODEL_FREE_ROTOR]:
com.append(
pipe_centre_of_mass(verbosity=0, missing_error=False))
else:
com.append(pivot1)
# Generate the rotor axis.
axes = generate_axis_system(sim_index=sim_indices[i])
axis.append(axes[:, 2])
# The size of the rotor (Angstrom), taking the cone representation into account by adding 5 Angstrom.
if cdp.model in [MODEL_ROTOR, MODEL_FREE_ROTOR]:
span.append(size)
else:
span.append(size + 5.0)
# Stagger the propeller blades.
if cdp.model in MODEL_LIST_FREE_ROTORS:
staggered.append(False)
else:
staggered.append(True)
# The pivot.
pivot.append(pivot1)
# The label.
label.append('z-ax')
# The models.
if sims:
models.append(model_nums[i])
else:
models.append(None)
# The double rotor models.
elif cdp.model in [MODEL_DOUBLE_ROTOR]:
# Add both rotor angles (the 2nd must come first).
if sims:
rotor_angle.append(cdp.cone_sigma_max_2_sim[sim_indices[i]])
rotor_angle.append(cdp.cone_sigma_max_sim[sim_indices[i]])
else:
rotor_angle.append(cdp.cone_sigma_max_2)
rotor_angle.append(cdp.cone_sigma_max)
# Set the com to the pivot points.
com.append(pivot2)
com.append(pivot1)
# Generate the eigenframe of the motion.
frame = generate_axis_system(sim_index=sim_indices[i])
# Add the x and y axes.
axis.append(frame[:, 0])
axis.append(frame[:, 1])
# The rotor size (Angstrom).
span.append(size)
span.append(size)
# Stagger the propeller blades.
staggered.append(True)
staggered.append(True)
# The pivot points.
pivot.append(pivot2)
pivot.append(pivot1)
# The labels.
label.append('x-ax')
label.append('y-ax')
# The models.
if sims:
models.append(model_nums[i])
models.append(model_nums[i])
else:
models.append(None)
models.append(None)
# Add each rotor to the structure as a new molecule.
for i in range(len(axis)):
rotor(structure=structure,
rotor_angle=rotor_angle[i],
axis=dot(T, axis[i]),
axis_pt=pivot[i],
label=label[i],
centre=com[i],
span=span[i] / 1e10,
blade_length=5e-10,
model_num=models[i],
staggered=staggered[i],
half_rotor=half_rotor)