def write_tlsout_file(self, chain, cpartition):
"""Writes the TLSOUT file for the segmentation.
"""
basename = "%s_CHAIN%s_NTLS%d" % (self.struct_id, chain.chain_id,
cpartition.num_tls_segments())
tlsout_path = "%s.tlsout" % (basename)
struct_id = self.struct_id
chain_id = chain.chain_id
tls_file = TLS.TLSFile()
tls_file.set_file_format(TLS.TLSFileFormatTLSOUT())
for tls in cpartition.iter_tls_segments():
## don't write out bypass edges
if tls.method != "TLS":
continue
tls_desc = TLS.TLSGroupDesc()
tls_file.tls_desc_list.append(tls_desc)
tls_desc.set_tls_group(tls.tls_group)
for frag_id1, frag_id2 in tls.iter_segment_ranges():
tls_desc.add_range(chain_id, frag_id1, chain_id, frag_id2,
"ALL")
tls_file.save(open(tlsout_path, "w"))
return tlsout_path
def main(pdb_path, tls_out_path, calc_tls):
struct = FileIO.LoadStructure(file=pdb_path)
## calculate one set of TLS tensors from all the amino acid atoms
if calc_tls == True:
tls = TLS.TLSGroup()
for res in struct.iter_amino_acids():
for atm in res.iter_atoms():
tls.append(atm)
tls.origin = tls.calc_centroid()
tls.calc_tls_tensors()
print_TLSGroup(tls)
else:
tls_file = TLS.TLSFile()
## get TLS groups from REMARK statments in PDB file
if tls_out_path == None:
tls_file.set_file_format(TLS.TLSFileFormatPDB())
try:
tls_file.load(open(pdb_path, "r"), pdb_path)
except IOError, e:
print "[Error] %s: %s" % (str(e), pdb_path)
## or get TLS groups from REFMAC TLSOUT file
else:
def LoadStructure(struct_source):
"""Loads Structure, chooses a unique struct_id string.
Also, search the REMARK records for TLS group records. If they
are found, then add the TLS group ADP magnitude to the B facors of
the ATOM records.
"""
## determine the argument type
if isinstance(struct_source, str):
file_path = struct_source
console.kvformat("LOADING STRUCTURE", file_path)
fobj = open(file_path, "r")
elif hasattr(struct_source, "__iter__") and hasattr(struct_source, "seek"):
console.kvformat("LOADING STRUCTURE", str(struct_source))
fobj = struct_source
else:
raise ValueError
## load struct
struct = FileIO.LoadStructure(file = fobj, distance_bonds = True)
console.kvformat("HEADER", struct.header)
console.kvformat("TITLE", struct.title)
console.kvformat("EXPERIMENTAL METHOD", struct.experimental_method)
## set the structure ID
if conf.globalconf.struct_id is not None:
struct_id = conf.globalconf.struct_id
else:
struct_id = struct.structure_id
conf.globalconf.struct_id = struct_id
struct.structure_id = struct_id
console.endln()
## if there are REFMAC5 TLS groups in the REMARK records of
## the PDB file, then add those in
tls_file = TLS.TLSFile()
tls_file.set_file_format(TLS.TLSFileFormatPDB())
## return to the beginning of the file and read the REMARK/TLS records
fobj.seek(0)
tls_file.load(fobj)
if len(tls_file.tls_desc_list) > 0:
console.stdoutln("ADDING TLS GROUP Bequiv TO ATOM TEMPERATURE FACTORS")
console.stdoutln(" NUM TLS GROUPS: %d" % (len(tls_file.tls_desc_list)))
## assume REFMAC5 groups where Utotal = Utls + Biso(temp_factor)
for tls_desc in tls_file.tls_desc_list:
tls_group = tls_desc.construct_tls_group_with_atoms(struct)
console.stdoutln(" TLS GROUP: %s" % (tls_group.name))
for atm, Utls in tls_group.iter_atm_Utls():
bresi = atm.temp_factor
atm.temp_factor = bresi + (Constants.U2B * numpy.trace(Utls) / 3.0)
atm.U = (Constants.B2U * bresi * numpy.identity(3, float)) + Utls
console.endln()
return struct
def fit_to_chain(self, chain):
"""Re-sets all derived information in the TLSSegment.
"""
## cut segment from chain using segment ranges
segments = []
for frag_id1, frag_id2 in self.segment_ranges:
segments.append(chain[frag_id1:frag_id2])
self.segments = segments
## put all atoms in the segment into a new TLSGroup instance
tls_group = TLS.TLSGroup()
for segment in self.segments:
for atm in segment.iter_all_atoms():
if atm.include is True:
tls_group.append(atm)
self.tls_group = tls_group
if len(self.tls_group) != self.num_atoms():
console.stderrln(
"fit_to_chain: EEK! (%s) len(self.tls_group)=%d != self.num_atoms()=%d"
% (self, len(self.tls_group), self.num_atoms()))
raise SystemExit
## fit the TLS group parameters
try:
self.fit_tls_parameters(chain)
except:
print console.formatExceptionInfo()
## helpful additions
tls_info = self.tls_group.calc_tls_info()
itls_info = TLS.calc_itls_center_of_reaction(self.tls_group.itls_T,
self.tls_group.itls_L,
self.tls_group.itls_S,
self.tls_group.origin)
self.tls_info = tls_info
self.itls_info = itls_info
if conf.globalconf.tls_model in ["ISOT", "NLISOT"]:
self.tls_group.model = "ISOT"
self.model_tls_info = itls_info
elif conf.globalconf.tls_model in ["ANISO", "NLANISO"]:
self.tls_group.model = "ANISO"
self.model_tls_info = tls_info
try:
self.rmsd_b = tls_calcs.calc_rmsd_tls_biso(self.tls_group)
except:
print console.formatExceptionInfo()
def refmac_pure_tls_prep(xyzin, tlsin_list, wilson, xyzout, tlsout):
"""Use TLS model (without Uiso) for each atom. Output xyzout with the
B-factors reset to either the Bmean or the Wilson B value.
"""
## load structure
struct = FileIO.LoadStructure(fil=xyzin)
## load and construct TLS groups
tls_group_list = []
tls_file = TLS.TLSFile()
tls_file.set_file_format(TLS.TLSFileFormatPureTLSOUT())
tls_file_format = TLS.TLSFileFormatPureTLSOUT()
for tlsin in tlsin_list:
tls_desc_list = tls_file_format.load(open(tlsin, "r"))
for tls_desc in tls_desc_list:
tls_file.tls_desc_list.append(tls_desc)
tls_group = tls_desc.construct_tls_group_with_atoms(struct)
tls_group.tls_desc = tls_desc
tls_group_list.append(tls_group)
## set the extra Uiso for each atom
for tls_group in tls_group_list:
Bmean = 0.0
sum_Biso = 0.0
num_atms = 0
for atm, Utls in tls_group.iter_atm_Utls():
num_atms += 1
sum_Biso += atm.temp_factor
## EAM Aug 2011: num_atms goes to zero if there are atom selection problems.
## The output files will contain empty groups, but at least it doesn't crash.
if num_atms > 0:
Bmean = sum_Biso / num_atms
## reset the TLS tensor values in the TLSDesc object so they can be
## saved
tls_group.tls_desc.set_tls_group(tls_group)
## reset atm.temp_factor to the Bmean for this TLS group
for atm, Utls in tls_group.iter_atm_Utls():
atm.temp_factor = Bmean
atm.temp_factor = wilson
## save the new xyzout file with temp_factors reset to "wilson" value
FileIO.SaveStructure(fil=xyzout, struct=struct)
## save the REFMAC-format file, but without T, L, S, and ORIGIN values
tls_file.save(open(tlsout, "w"))
def calc_mean_biso_tls(chain, cpartition):
"""Calculates the mean B value per residue in the chain (as calculated in
the chain optimization). It also performs a Skittles evaluation of the
junctions between the "C" and "N" atoms of neighbouring residues.
"""
chain_id = chain.chain_id
num_tls = cpartition.num_tls_segments()
num_res = chain.count_fragments()
biso = numpy.zeros(num_res, float)
for i, tls in enumerate(cpartition.iter_tls_segments()):
tls_group = tls.tls_group
T = tls_group.itls_T # float(3)
L = tls_group.itls_L # array(3,3)
S = tls_group.itls_S # array(3): S[0], S[1], S[2]
O = tls_group.origin # array(3)
for frag in tls.iter_fragments():
n = 0
b_sum_tls = 0.0
for atm in frag.iter_all_atoms():
if atm.include is False:
continue
n += 1
b_sum_tls += Constants.U2B * TLS.calc_itls_uiso(
T, L, S, atm.position - O)
if n > 0:
biso[frag.ifrag] = b_sum_tls / n
return biso
def write_data_file(self):
nrows = len(self.cpartition.chain)
ncols = self.cpartition.num_tls_segments() + 1
tbl = table.StringTable(nrows, ncols, "?")
frag_id_iter = itertools.imap(lambda frag: frag.fragment_id, self.cpartition.chain.iter_fragments())
tbl.set_column(0, 0, frag_id_iter)
for itls, tls in enumerate(self.cpartition.iter_tls_segments()):
tls_group = tls.tls_group
T = tls_group.itls_T
L = tls_group.itls_L
S = tls_group.itls_S
O = tls_group.origin
for frag in tls.iter_fragments():
atm = frag.get_atom("CA")
if atm is None:
continue
i = frag.ifrag
b_tls = Constants.U2B * TLS.calc_itls_uiso(T, L, S, atm.position - O)
tbl[i, itls + 1] = atm.temp_factor - b_tls
open(self.txt_path, "w").write(str(tbl))
def calc_mean_biso_tls(chain, cpartition):
"""Calculated the mean B value per residue in the chain
as calculated in the chain optimization.
"""
num_res = chain.count_fragments()
biso = numpy.zeros(num_res, float)
for i, tls in enumerate(cpartition.iter_tls_segments()):
tls_group = tls.tls_group
T = tls_group.itls_T
L = tls_group.itls_L
S = tls_group.itls_S
O = tls_group.origin
for frag in tls.iter_fragments():
n = 0
b_sum_tls = 0.0
for atm in frag.iter_all_atoms():
if atm.include is False:
continue
n += 1
b_sum_tls += Constants.U2B * TLS.calc_itls_uiso(T, L, S, atm.position - O)
if n > 0:
biso[frag.ifrag] = b_sum_tls / n
return biso
def calc_mean_biso_tls(chain, cpartition):
"""Calculates the mean B value per residue in the chain (as calculated in
the chain optimization). It also performs a Skittles evaluation of the
junctions between the "C" and "N" atoms of neighbouring residues.
"""
chain_id = chain.chain_id
num_tls = cpartition.num_tls_segments()
num_res = chain.count_fragments()
biso = numpy.zeros(num_res, float)
for i, tls in enumerate(cpartition.iter_tls_segments()):
tls_group = tls.tls_group
T = tls_group.itls_T # float(3)
L = tls_group.itls_L # array(3,3)
S = tls_group.itls_S # array(3): S[0], S[1], S[2]
O = tls_group.origin # array(3)
for frag in tls.iter_fragments():
n = 0
b_sum_tls = 0.0
for atm in frag.iter_all_atoms():
if atm.include is False:
continue
n += 1
b_sum_tls += Constants.U2B * TLS.calc_itls_uiso(
T, L, S, atm.position - O)
if n > 0:
biso[frag.ifrag] = b_sum_tls / n
return biso
def write_data_file(self):
"""Generate the data file and return the filename.
"""
nrows = len(self.cpartition.chain)
ncols = 1 + 3 * self.cpartition.num_tls_segments()
tbl = table.StringTable(nrows, ncols, "?")
mpred = lambda f: f.fragment_id
frag_id_iter = itertools.imap(mpred, self.cpartition.chain.iter_fragments())
tbl.set_column(0, 0, frag_id_iter)
for itls, tls in enumerate(self.cpartition.iter_tls_segments()):
tls_group = tls.tls_group
tls_info = tls.model_tls_info
O = tls_info["COR"]
for frag in tls.iter_fragments():
## FIXME: This should be able to handle either one
atm = frag.get_atom("CA") ## for amino acids
# atm = frag.get_atom("P") ## for nucleic acids
if atm is None:
continue
# if frag.get_atom("CA") is not None:
# atm = frag.get_atom("CA")
# console.stdoutln("CA_ATOM: %s" % str(atm))
# elif frag.get_atom("P") is not None:
# atm = frag.get_atom("P")
i = frag.ifrag
for n, Lx_val, Lx_vec, Lx_rho, Lx_pitch in [
(0, "L1_eigen_val", "L1_eigen_vec", "L1_rho", "L1_pitch"),
(1, "L2_eigen_val", "L2_eigen_vec", "L2_rho", "L2_pitch"),
(2, "L3_eigen_val", "L3_eigen_vec", "L3_rho", "L3_pitch"),
]:
Lval = tls_info[Lx_val]
Lvec = tls_info[Lx_vec]
Lrho = tls_info[Lx_rho]
Lpitch = tls_info[Lx_pitch]
if numpy.allclose(Lval, 0.0):
continue
dvec = TLS.calc_LS_displacement(O, Lval, Lvec, Lrho, Lpitch, atm.position, conf.ADP_PROB)
tbl[i, 1 + 3 * itls + n] = AtomMath.length(dvec)
flatfile_write(
"LibrationAnalysis: data", "LIAN", "DATA", str(tbl), self.chain.chain_id, self.cpartition.num_tls_segments()
)
open(self.txt_path, "w").write(str(tbl))
def IsotropicADPDataSmoother(chain, num_smooth=1):
"""Experimental data smoothing of temperature factors
"""
console.endln()
console.stdoutln("SMOOTHING CHAIN %s ADPs" % (chain.chain_id))
conesole.kvformat("SMOOTH WINDOW", 2 * num_smooth + 1)
num_frags = len(chain)
smooth_uiso = dict()
ifrag_start = num_smooth
ifrag_end = num_frags - num_smooth - 1
for ifrag in xrange(ifrag_start, ifrag_end + 1):
smooth_frag = chain[ifrag]
frag1 = chain[ifrag - num_smooth]
frag2 = chain[ifrag + num_smooth]
IT, IL, IS, IOrigin = IsotropicFitSegmentOutlierRejection(
chain, frag1.fragment_id, frag2.fragment_id)
for atm, uiso in TLS.iter_itls_uiso(smooth_frag.iter_all_atoms(), IT,
IL, IS, IOrigin):
smooth_uiso[atm] = uiso
if ifrag == ifrag_start:
for i in range(ifrag_start):
smooth_frag = chain[i]
for atm, uiso in TLS.iter_itls_uiso(
smooth_frag.iter_all_atoms(), IT, IL, IS, IOrigin):
smooth_uiso[atm] = uiso
elif ifrag == ifrag_end:
for i in range(ifrag_end + 1, num_frags):
smooth_frag = chain[i]
for atm, uiso in TLS.iter_itls_uiso(
smooth_frag.iter_all_atoms(), IT, IL, IS, IOrigin):
smooth_uiso[atm] = uiso
for atm, uiso in smooth_uiso.iteritems():
atm.temp_factor = Constants.U2B * uiso
atm.U = numpy.identity(3, float) * uiso
def IsotropicADPDataSmoother(chain, num_smooth = 1):
"""Experimental data smoothing of temperature factors.
"""
console.endln()
console.stdoutln("SMOOTHING CHAIN %s ADPs" % (chain.chain_id))
console.kvformat("SMOOTH WINDOW", 2 * num_smooth + 1)
num_frags = len(chain)
smooth_uiso = dict()
ifrag_start = num_smooth
ifrag_end = num_frags - num_smooth - 1
for ifrag in xrange(ifrag_start, ifrag_end + 1):
smooth_frag = chain[ifrag]
frag1 = chain[ifrag - num_smooth]
frag2 = chain[ifrag + num_smooth]
IT, IL, IS, IOrigin = IsotropicFitSegmentOutlierRejection(
chain, frag1.fragment_id, frag2.fragment_id)
for atm, uiso in TLS.iter_itls_uiso(smooth_frag.iter_all_atoms(),
IT, IL, IS, IOrigin):
smooth_uiso[atm] = uiso
if ifrag == ifrag_start:
for i in range(ifrag_start):
smooth_frag = chain[i]
for atm, uiso in TLS.iter_itls_uiso(smooth_frag.iter_all_atoms(),
IT, IL, IS, IOrigin):
smooth_uiso[atm] = uiso
elif ifrag == ifrag_end:
for i in range(ifrag_end + 1, num_frags):
smooth_frag = chain[i]
for atm, uiso in TLS.iter_itls_uiso(smooth_frag.iter_all_atoms(),
IT, IL, IS, IOrigin):
smooth_uiso[atm] = uiso
for atm, uiso in smooth_uiso.iteritems():
atm.temp_factor = Constants.U2B * uiso
atm.U = numpy.identity(3, float) * uiso
def phenix_prep(xyzin, phenix_tlsin_list, phenix_tlsout):
"""PHENIX input file. Tells 'phenix.refine' what the TLS groups are.
"""
## load structure
struct = FileIO.LoadStructure(fil=xyzin)
## load and construct TLS groups
tls_group_list = []
tls_file = TLS.TLSFile()
tls_file.set_file_format(TLS.TLSFileFormatPHENIX())
tls_file_format = TLS.TLSFileFormatPHENIX()
for tlsin in phenix_tlsin_list:
tls_desc_list = tls_file_format.load(open(tlsin, "r"))
for tls_desc in tls_desc_list:
tls_file.tls_desc_list.append(tls_desc)
tls_group = tls_desc.construct_tls_group_with_atoms(struct)
tls_group.tls_desc = tls_desc
tls_group_list.append(tls_group)
## now save the PHENIX file in phenix.refine format
tls_file.save(open(phenix_tlsout, "w"))
def fit_to_chain(self, chain):
"""Re-sets all derived information in the TLSSegment.
"""
## cut segment from chain using segment ranges
segments = []
for frag_id1, frag_id2 in self.segment_ranges:
segments.append(chain[frag_id1:frag_id2])
self.segments = segments
## put all atoms in the segment into a new TLSGroup instance
tls_group = TLS.TLSGroup()
for segment in self.segments:
for atm in segment.iter_all_atoms():
if atm.include is True:
tls_group.append(atm)
self.tls_group = tls_group
if len(self.tls_group) != self.num_atoms():
console.stderrln(
"fit_to_chain: EEK! (%s) len(self.tls_group)=%d != self.num_atoms()=%d" % (
self, len(self.tls_group), self.num_atoms()))
raise SystemExit
## fit the TLS group parameters
try:
self.fit_tls_parameters(chain)
except:
print console.formatExceptionInfo()
## helpful additions
tls_info = self.tls_group.calc_tls_info()
itls_info = TLS.calc_itls_center_of_reaction(
self.tls_group.itls_T,
self.tls_group.itls_L,
self.tls_group.itls_S,
self.tls_group.origin)
self.tls_info = tls_info
self.itls_info = itls_info
if conf.globalconf.tls_model in ["ISOT", "NLISOT"]:
self.tls_group.model = "ISOT"
self.model_tls_info = itls_info
elif conf.globalconf.tls_model in ["ANISO", "NLANISO"]:
self.tls_group.model = "ANISO"
self.model_tls_info = tls_info
try:
self.rmsd_b = tls_calcs.calc_rmsd_tls_biso(self.tls_group)
except:
print console.formatExceptionInfo()
def ResidualInfo(chain, range, tlsdict):
IT, IL, IS, IO = tls_calcs.isotlsdict2tensors(tlsdict)
num_atoms = 0
weight_sum = 0.0
msd_sum = 0.0
atomiter = iter_fragment_atoms(chain.iter_fragments(*range))
for atm, uiso_tls in TLS.iter_itls_uiso(atomiter, IT, IL, IS, IO):
num_atoms += 1
delta = atm.temp_factor - (Constants.U2B * uiso_tls)
msd_sum += atm.occupancy * delta**2
weight_sum += atm.occupancy
msd = msd_sum / weight_sum
return msd
def ResidualInfo(chain, range, tlsdict):
IT, IL, IS, IO = tls_calcs.isotlsdict2tensors(tlsdict)
num_atoms = 0
weight_sum = 0.0
msd_sum = 0.0
atomiter = iter_fragment_atoms(chain.iter_fragments(*range))
for atm, uiso_tls in TLS.iter_itls_uiso(atomiter, IT, IL, IS, IO):
num_atoms += 1
delta = atm.temp_factor - (Constants.U2B * uiso_tls)
msd_sum += atm.occupancy * delta**2
weight_sum += atm.occupancy
msd = msd_sum / weight_sum
return msd
def main(tlsin, struct_in, struct_out):
struct = FileIO.LoadStructure(file=struct_in)
## make the TLS groups
fil = open(tlsin, "r")
tls_file = TLS.TLSFile()
tls_file.set_file_format(TLS.TLSFileFormatTLSOUT())
tls_file.load(fil)
tls_group_list = []
for tls_desc in tls_file.tls_desc_list:
tls = tls_desc.construct_tls_group_with_atoms(struct)
tls.tls_desc = tls_desc
tls_group_list.append(tls)
print tls.origin
for tls in tls_group_list:
for atm, Utls in tls.iter_atm_Utls():
atm.U = Utls + (Constants.B2U * atm.temp_factor *
numpy.identity(3, float))
atm.temp_factor = Constants.U2B * (numpy.trace(atm.U) / 3.0)
## save the struct
FileIO.SaveStructure(file=struct_out, struct=struct)
def calc_residue_mean_rmsd(chain, cpartition):
"""Calculates the mean RMSD value per residue in a given chain.
"""
num_tls = cpartition.num_tls_segments()
num_res = chain.count_fragments()
#struct_id = cpartition.struct_id ## TODO: Find out how to get this
cmtx = numpy.zeros((num_tls, num_res), float)
i_ntls = 0
for i, tls in enumerate(cpartition.iter_tls_segments()):
tls_group = tls.tls_group
T = tls_group.itls_T # float(3)
L = tls_group.itls_L # array(3,3)
S = tls_group.itls_S # array(3): S[0], S[1], S[2]
O = tls_group.origin # array(3)
for j, frag in enumerate(chain):
## NOTE: j = res_num, frag = Res(ALA,23,A)
## calculate a atom-normalized rmsd deviation for each residue
num_atoms = 0
msd_sum = 0.0
for atm in frag.iter_all_atoms():
if atm.include == False:
continue
num_atoms += 1
b_iso_tls = Constants.U2B * TLS.calc_itls_uiso(
T, L, S, atm.position - O)
delta = atm.temp_factor - b_iso_tls
msd_sum += delta**2
if num_atoms > 0:
msd = msd_sum / num_atoms
rmsd = math.sqrt(msd)
## set the cross prediction matrix
cmtx[i, j] = rmsd
return cmtx
def calc_residue_mean_rmsd(chain, cpartition):
"""Calculates the mean RMSD value per residue in a given chain.
"""
num_tls = cpartition.num_tls_segments()
num_res = chain.count_fragments()
#struct_id = cpartition.struct_id ## TODO: Find out how to get this
cmtx = numpy.zeros((num_tls, num_res), float)
i_ntls = 0
for i, tls in enumerate(cpartition.iter_tls_segments()):
tls_group = tls.tls_group
T = tls_group.itls_T # float(3)
L = tls_group.itls_L # array(3,3)
S = tls_group.itls_S # array(3): S[0], S[1], S[2]
O = tls_group.origin # array(3)
for j, frag in enumerate(chain):
## NOTE: j = res_num, frag = Res(ALA,23,A)
## calculate a atom-normalized rmsd deviation for each residue
num_atoms = 0
msd_sum = 0.0
for atm in frag.iter_all_atoms():
if atm.include == False:
continue
num_atoms += 1
b_iso_tls = Constants.U2B * TLS.calc_itls_uiso(T, L, S, atm.position - O)
delta = atm.temp_factor - b_iso_tls
msd_sum += delta**2
if num_atoms > 0:
msd = msd_sum / num_atoms
rmsd = math.sqrt(msd)
## set the cross prediction matrix
cmtx[i,j] = rmsd
return cmtx
def calc_rmsd_tls_biso(tls_group):
"""Calculate the RMSD of the tls_group using the isotropic TLS model.
"""
T = tls_group.itls_T
L = tls_group.itls_L
S = tls_group.itls_S
O = tls_group.origin
msd_sum = 0.0
for atm, uiso_tls in TLS.iter_itls_uiso(iter(tls_group), T, L, S, O):
msd_sum += (Constants.U2B*uiso_tls - atm.temp_factor)**2
if len(tls_group)>0:
msd = msd_sum / len(tls_group)
rmsd = math.sqrt(msd)
else:
rmsd = 0.0
return rmsd
def IsotropicFitSegmentOutlierRejection(chain, frag_id1, frag_id2):
segment = chain[frag_id1:frag_id2]
atoms = list(segment.iter_all_atoms())
orig_num_atoms = len(atoms)
rejected = 0
while True:
tls_analyzer = tlsmdmodule.TLSModelAnalyzer()
xlist = atom_selection.chain_to_xmlrpc_list(iter(atoms))
tls_analyzer.set_xmlrpc_chain(xlist)
tlsdict = tls_analyzer.isotropic_fit_segment(frag_id1, frag_id2)
IT, IL, IS, IOrigin = tls_calcs.isotlsdict2tensors(tlsdict)
num_atoms = 0
msd_sum = 0.0
atm_deltab = []
for atm, uiso in TLS.iter_itls_uiso(iter(atoms), IT, IL, IS, IOrigin):
num_atoms += 1
deltab = atm.temp_factor - (Constants.U2B * uiso)
msd_sum += deltab**2
atm_deltab.append((deltab, atm))
sigma = math.sqrt((msd_sum / num_atoms))
sigma2 = 2.0 * sigma
outliers = 0
for deltab, atm in atm_deltab:
if abs(deltab) > sigma2:
atoms.remove(atm)
outliers += 1
rejected += outliers
if outliers == 0 or (num_atoms - outliers) < 10:
console.stdoutln("SEGMENT %s-%s %d->%d" %
(frag_id1, frag_id2, orig_num_atoms,
orig_num_atoms - rejected))
return IT, IL, IS, IOrigin
def tlsdict2tensors(tlsdict):
"""Convert the result dictionaries returned by tlsmdmodule to NumPy
tensors.
"""
origin = numpy.array([tlsdict["x"], tlsdict["y"], tlsdict["z"]], float)
T = numpy.array([[tlsdict["t11"], tlsdict["t12"], tlsdict["t13"]],
[tlsdict["t12"], tlsdict["t22"], tlsdict["t23"]],
[tlsdict["t13"], tlsdict["t23"], tlsdict["t33"]]], float)
L = numpy.array([[tlsdict["l11"], tlsdict["l12"], tlsdict["l13"]],
[tlsdict["l12"], tlsdict["l22"], tlsdict["l23"]],
[tlsdict["l13"], tlsdict["l23"], tlsdict["l33"]]], float)
s11, s22, s33 = TLS.calc_s11_s22_s33(tlsdict["s2211"], tlsdict["s1133"])
S = numpy.array([[s11, tlsdict["s12"], tlsdict["s13"]],
[tlsdict["s21"], s22, tlsdict["s23"]],
[tlsdict["s31"], tlsdict["s32"], s33]], float)
return T, L, S, origin
def write_data_file(self):
"""Generate the data file and return the filename.
"""
nrows = len(self.cpartition.chain)
ncols = 1 + 3 * self.cpartition.num_tls_segments()
tbl = table.StringTable(nrows, ncols, "?")
mpred = lambda f: f.fragment_id
frag_id_iter = itertools.imap(mpred, self.cpartition.chain.iter_fragments())
tbl.set_column(0, 0, frag_id_iter)
for itls, tls in enumerate(self.cpartition.iter_tls_segments()):
tls_group = tls.tls_group
tls_info = tls.model_tls_info
O = tls_info["COR"]
for frag in tls.iter_fragments():
atm = frag.get_atom("CA")
if atm is None:
continue
i = frag.ifrag
for n, Lx_val, Lx_vec, Lx_rho, Lx_pitch in [
(0, "L1_eigen_val", "L1_eigen_vec", "L1_rho", "L1_pitch"),
(1, "L2_eigen_val", "L2_eigen_vec", "L2_rho", "L2_pitch"),
(2, "L3_eigen_val", "L3_eigen_vec", "L3_rho", "L3_pitch") ]:
Lval = tls_info[Lx_val]
Lvec = tls_info[Lx_vec]
Lrho = tls_info[Lx_rho]
Lpitch = tls_info[Lx_pitch]
if numpy.allclose(Lval, 0.0):
continue
dvec = TLS.calc_LS_displacement(O, Lval, Lvec, Lrho, Lpitch, atm.position, settings.ADP_PROB)
tbl[i, 1 + 3*itls + n] = AtomMath.length(dvec)
open(self.txt_path, "w").write(str(tbl))
def IsotropicFitSegmentOutlierRejection(chain, frag_id1, frag_id2):
segment = chain[frag_id1:frag_id2]
atoms = list(segment.iter_all_atoms())
orig_num_atoms = len(atoms)
rejected = 0
while True:
tls_analyzer = tlsmdmodule.TLSModelAnalyzer()
xlist = atom_selection.chain_to_xmlrpc_list(iter(atoms))
tls_analyzer.set_xmlrpc_chain(xlist)
tlsdict = tls_analyzer.isotropic_fit_segment(frag_id1, frag_id2)
IT, IL, IS, IOrigin = tls_calcs.isotlsdict2tensors(tlsdict)
num_atoms = 0
msd_sum = 0.0
atm_deltab = []
for atm, uiso in TLS.iter_itls_uiso(iter(atoms), IT, IL, IS, IOrigin):
num_atoms += 1;
deltab = atm.temp_factor - (Constants.U2B * uiso)
msd_sum += deltab**2
atm_deltab.append((deltab, atm))
sigma = math.sqrt((msd_sum / num_atoms))
sigma2 = 2.0 * sigma
outliers = 0
for deltab, atm in atm_deltab:
if abs(deltab) > sigma2:
atoms.remove(atm)
outliers += 1
rejected += outliers
if outliers == 0 or (num_atoms - outliers) < 10:
console.stdoutln("SEGMENT %s-%s %d->%d" % (
frag_id1, frag_id2, orig_num_atoms, orig_num_atoms - rejected))
return IT, IL, IS, IOrigin
def calc_residue_mean_rmsd(chain, cpartition):
num_tls = cpartition.num_tls_segments()
num_res = chain.count_fragments()
cmtx = numpy.zeros((num_tls, num_res), float)
for i, tls in enumerate(cpartition.iter_tls_segments()):
tls_group = tls.tls_group
T = tls_group.itls_T
L = tls_group.itls_L
S = tls_group.itls_S
O = tls_group.origin
for j, frag in enumerate(chain):
## calculate a atom-normalized rmsd deviation for each residue
num_atoms = 0
msd_sum = 0.0
for atm in frag.iter_all_atoms():
if atm.include == False:
continue
num_atoms += 1
b_iso_tls = Constants.U2B * TLS.calc_itls_uiso(T, L, S, atm.position - O)
delta = atm.temp_factor - b_iso_tls
msd_sum += delta**2
if num_atoms > 0:
msd = msd_sum / num_atoms
rmsd = math.sqrt(msd)
## set the cross prediction matrix
cmtx[i,j] = rmsd
return cmtx
def tlsdict2tensors(tlsdict):
"""Convert the result dictionaries returned by tlsmdmodule to NumPy
tensors.
"""
origin = numpy.array([tlsdict["x"], tlsdict["y"], tlsdict["z"]], float)
T = numpy.array(
[ [tlsdict["t11"], tlsdict["t12"], tlsdict["t13"]],
[tlsdict["t12"], tlsdict["t22"], tlsdict["t23"]],
[tlsdict["t13"], tlsdict["t23"], tlsdict["t33"]] ], float)
L = numpy.array(
[ [tlsdict["l11"], tlsdict["l12"], tlsdict["l13"]],
[tlsdict["l12"], tlsdict["l22"], tlsdict["l23"]],
[tlsdict["l13"], tlsdict["l23"], tlsdict["l33"]] ], float)
s11, s22, s33 = TLS.calc_s11_s22_s33(tlsdict["s2211"], tlsdict["s1133"])
S = numpy.array(
[ [ s11, tlsdict["s12"], tlsdict["s13"]],
[tlsdict["s21"], s22, tlsdict["s23"]],
[tlsdict["s31"], tlsdict["s32"], s33] ], float)
return T, L, S, origin
def write_data_file(self):
nrows = len(self.cpartition.chain)
ncols = self.cpartition.num_tls_segments() + 1
tbl = table.StringTable(nrows, ncols, "?")
frag_id_iter = itertools.imap(lambda frag: frag.fragment_id, self.cpartition.chain.iter_fragments())
tbl.set_column(0, 0, frag_id_iter)
for itls, tls in enumerate(self.cpartition.iter_tls_segments()):
tls_group = tls.tls_group
T = tls_group.itls_T
L = tls_group.itls_L
S = tls_group.itls_S
O = tls_group.origin
for frag in tls.iter_fragments():
## FIXME: This should be able to handle either one
atm = frag.get_atom("CA") ## for amino acids
# atm = frag.get_atom("P") ## for nucleic acids
if atm is None:
continue
i = frag.ifrag
b_tls = Constants.U2B * TLS.calc_itls_uiso(T, L, S, atm.position - O)
tbl[i, itls + 1] = atm.temp_factor - b_tls
open(self.txt_path, "w").write(str(tbl))
flatfile_write(
"CA_TLS_Differance_Plot: data",
"CTDP",
"DATA",
str(tbl),
self.chain.chain_id,
self.cpartition.num_tls_segments(),
)
def main(path, opt_dict):
struct = FileIO.LoadStructure(file=path)
tls_group_list = []
## make the TLS groups
if opt_dict.has_key("-t"):
try:
fil = open(opt_dict["-t"], "r")
except IOError:
print "[ERROR]: TLSIN File not found %s" % (opt_dict["-t"])
sys.exit(-1)
tls_file = TLS.TLSFile()
tls_file.set_file_format(TLS.TLSFileFormatTLSOUT())
tls_file.load(fil)
for tls_desc in tls_file.tls_desc_list:
tls = tls_desc.construct_tls_group_with_atoms(struct)
tls.tls_desc = tls_desc
tls_group_list.append(tls)
else:
## create one TLS group per chain by default
for chain in struct.iter_chains():
if chain.count_amino_acids() < 10:
continue
try:
chain_id1 = chain.chain_id
frag_id1 = chain[0].fragment_id
frag_id2 = chain[-1].fragment_id
except IndexError:
continue
tls_desc = TLS.TLSGroupDesc()
tls_desc.add_range(chain_id1, frag_id1, chain_id1, frag_id2, "ALL")
tls = tls_desc.construct_tls_group_with_atoms(struct)
tls_group_list.append(tls)
tls.tls_desc = tls_desc
print "Creating TLS Group: %s" % (tls.name)
## fit TLS groups and write output
tls_file = TLS.TLSFile()
tls_file.set_file_format(TLS.TLSFileFormatTLSOUT())
## preform a LSQ fit if necessary
for tls in tls_group_list:
print "[TLS GROUP %s]" % (tls.name)
## if the TLS group is null, then perform a LSQ-TLS fit
if tls.is_null():
print "Null Group: Running TLS-LSQ"
if len(tls) < 20:
print "ERROR: Not Enough Atoms in TLS Group."
continue
tls.origin = tls.calc_centroid()
lsq_residual = tls.calc_TLS_least_squares_fit()
tls.shift_COR()
tls.tls_desc.set_tls_group(tls)
tls_file.tls_desc_list.append(tls.tls_desc)
if opt_dict.has_key("-o"):
print "Saving TLSIN: %s" % (opt_dict["-o"])
tls_file.save(open(opt_dict["-o"], "w"))
## write out a PDB file with 0.0 tempature factors for all
## atoms in TLS groups
if opt_dict.has_key("-p"):
for tls in tls_group_list:
for atm, Utls in tls.iter_atm_Utls():
if opt_dict.has_key("-s"):
atm.temp_factor = 0.0
atm.U = None
else:
atm.temp_factor = Constants.U2B * numpy.trace(Utls) / 3.0
atm.U = Utls
## save the struct
print "Saving XYZIN: %s" % (opt_dict["-p"])
FileIO.SaveStructure(file=opt_dict["-p"], struct=struct)
def main(path, opt_dict):
struct = FileIO.LoadStructure(file = path)
tls_group_list = []
## make the TLS groups
if opt_dict.has_key("-t"):
try:
fil = open(opt_dict["-t"], "r")
except IOError:
print "ERROR: TLSIN File not found %s" % (opt_dict["-t"])
sys.exit(-1)
tls_file = TLS.TLSFile()
tls_file.set_file_format(TLS.TLSFileFormatTLSOUT())
tls_file.load(fil)
for tls_desc in tls_file.tls_desc_list:
#tls = tls_desc.generate_tls_group(struct) ## old def
tls = tls_desc.construct_tls_group_with_atoms(struct)
tls.tls_desc = tls_desc
tls_group_list.append(tls)
print tls.name
else:
tls_desc = TLS.TLSGroupDesc()
tls_desc.add_range("A", "1", "A", "25", "ALL")
tls_group = tls_desc.construct_tls_group_with_atoms(struct)
tls_group_list.append(tls_group)
tls_group.tls_desc = tls_desc
tls_group.origin = tls_group.calc_centroid()
tls_group.T = rt_random(T1)
tls_group.L, tls_group.S = rt_random2(L1, S1)
tls_desc = TLS.TLSGroupDesc()
tls_desc.add_range("A", "26", "A", "35", "ALL")
tls_group = tls_desc.construct_tls_group_with_atoms(struct)
tls_group_list.append(tls_group)
tls_group.tls_desc = tls_desc
tls_group.origin = tls_group.calc_centroid()
tls_group.T = rt_random(T2)
tls_group.L, tls_group.S = rt_random2(L2, S1)
tls_desc = TLS.TLSGroupDesc()
tls_desc.add_range("A", "36", "A", "52", "ALL")
tls_group = tls_desc.construct_tls_group_with_atoms(struct)
tls_group_list.append(tls_group)
tls_group.tls_desc = tls_desc
tls_group.origin = tls_group.calc_centroid()
tls_group.T = rt_random(T3)
tls_group.L, tls_group.S = rt_random2(L3, S1)
for atm in struct.iter_all_atoms():
atm.U = None
## write out ideal TLS ANISOU records
if opt_dict.has_key("-p"):
for tls_group in tls_group_list:
for atm, Utls in tls_group.iter_atm_Utls():
atm.temp_factor = Constants.U2B * (numpy.trace(Utls) / 3.0)
atm.U = Utls
## save the struct
FileIO.SaveStructure(file = opt_dict["-p"], struct = struct)
def refmac5_prep(xyzin, tlsin_list, xyzout, tlsout):
"""Use TLS model + Uiso for each atom. Output xyzout with the
residual Uiso only.
"""
## load structure
struct = FileIO.LoadStructure(fil = xyzin)
## load and construct TLS groups
tls_group_list = []
tls_file = TLS.TLSFile()
tls_file.set_file_format(TLS.TLSFileFormatTLSOUT())
tls_file_format = TLS.TLSFileFormatTLSOUT()
for tlsin in tlsin_list:
tls_desc_list = tls_file_format.load(open(tlsin, "r"))
for tls_desc in tls_desc_list:
tls_file.tls_desc_list.append(tls_desc)
tls_group = tls_desc.construct_tls_group_with_atoms(struct)
tls_group.tls_desc = tls_desc
tls_group_list.append(tls_group)
## set the extra Uiso for each atom
for tls_group in tls_group_list:
## minimal/maximal amount of Uiso which has to be added
## to the group's atoms to to make Uiso == Uiso_tls
min_Uiso = 0.0
max_Uiso = 0.0
for atm, Utls in tls_group.iter_atm_Utls():
tls_tf = numpy.trace(Utls) / 3.0
ref_tf = numpy.trace(atm.get_U()) / 3.0
if ref_tf > tls_tf:
max_Uiso = max(ref_tf - tls_tf, max_Uiso)
else:
min_Uiso = max(tls_tf - ref_tf, min_Uiso)
## reduce the TLS group T tensor by min_Uiso so that
## a PDB file can be written out where all atoms
## Uiso == Uiso_tls
## we must rotate the T tensor to its primary axes before
## subtracting min_Uiso magnitude from it
(T_eval, TR) = numpy.linalg.eig(tls_group.T)
T = numpy.dot(TR, numpy.dot(tls_group.T, numpy.transpose(TR)))
assert numpy.allclose(T[0,1], 0.0)
assert numpy.allclose(T[0,2], 0.0)
assert numpy.allclose(T[1,2], 0.0)
T[0,0] = T[0,0] - min_Uiso
T[1,1] = T[1,1] - min_Uiso
T[2,2] = T[2,2] - min_Uiso
## now take some of the smallest principal component of T and
## move it into the individual atomic temperature factors
min_T = min(T[0,0], min(T[1,1], T[2,2]))
sub_T = min_T * 0.50
add_Uiso = min_T - sub_T
T[0,0] = T[0,0] - sub_T
T[1,1] = T[1,1] - sub_T
T[2,2] = T[2,2] - sub_T
## rotate T back to original orientation
tls_group.T = numpy.dot(
numpy.transpose(TR),
numpy.dot(T, TR))
## reset the TLS tensor values in the TLSDesc object so they can be saved
tls_group.tls_desc.set_tls_group(tls_group)
## set atm.temp_factor
for atm, Utls in tls_group.iter_atm_Utls():
tls_tf = numpy.trace(Utls) / 3.0
ref_tf = numpy.trace(atm.get_U()) / 3.0
if ref_tf > tls_tf:
atm.temp_factor = ((add_Uiso) + ref_tf - tls_tf)*Constants.U2B
atm.U = None
else:
atm.temp_factor = (add_Uiso) * Constants.U2B
atm.U = None
FileIO.SaveStructure(fil = xyzout, struct = struct)
tls_file.save(open(tlsout, "w"))
def make_script(self):
tls = self.tls
## generate data and png paths
basename = "%s_CHAIN%s_TLS%s_BoBc" % (
self.chain.struct.structure_id,
self.chain.chain_id,
tls.filename_label())
self.set_basename(basename)
## write out the data file
tls_group = tls.tls_group
T = tls_group.itls_T
L = tls_group.itls_L
S = tls_group.itls_S
O = tls_group.origin
## create a histogram of (Uiso - Utls_iso)
bdiff_min = 0.0
bdiff_max = 0.0
for atm in tls_group:
b_iso_tls = Constants.U2B * TLS.calc_itls_uiso(T, L, S, atm.position - O)
bdiff = atm.temp_factor - b_iso_tls
bdiff_min = min(bdiff_min, bdiff)
bdiff_max = max(bdiff_max, bdiff)
## compute the bin width and range to bin over
brange = (bdiff_max - bdiff_min) + 2.0
num_bins = int(brange)
bin_width = brange / float(num_bins)
bins = [0 for n in xrange(num_bins)]
## name the bins with their mean value
bin_names = []
for n in xrange(num_bins):
bin_mean = bdiff_min + (float(n) * bin_width) + (bin_width / 2.0)
bin_names.append(bin_mean)
## count the bins
for atm in tls_group:
b_iso_tls = Constants.U2B * TLS.calc_itls_uiso(T, L, S, atm.position - O)
bdiff = atm.temp_factor - b_iso_tls
bin = int((bdiff - bdiff_min)/ bin_width)
bins[bin] += 1
## write out the gnuplot input file
fil = open(self.txt_path, "w")
fil.write("## Histogram of atoms in the TLS group binned by\n")
fil.write("## the difference of their isotropic temperature factors\n")
fil.write("## from the isotropic values predicted from the TLS model.\n")
fil.write("##\n")
fil.write("## Structure ----------------: %s\n" % (self.chain.struct.structure_id))
fil.write("## Chain --------------------: %s\n" % (self.chain.chain_id))
fil.write("## TLS Group Residue Range --: %s\n" % (tls.display_label()))
for i in xrange(len(bins)):
fil.write("%f %d\n" % (bin_names[i], bins[i]))
fil.close()
## modify script template
script = _UISO_VS_UTLSISO_HISTOGRAM_TEMPLATE
script = script.replace("<txtfile>", self.txt_path)
title = "Histogram of Observed B_{iso} - B_{tls} for TLS Group %s" % (tls.display_label())
script = script.replace("<title>", title)
script = script.replace("<rgb>", tls.color.rgbs)
return script
print_TLSGroup(tls)
else:
tls_file = TLS.TLSFile()
## get TLS groups from REMARK statments in PDB file
if tls_out_path == None:
tls_file.set_file_format(TLS.TLSFileFormatPDB())
try:
tls_file.load(open(pdb_path, "r"), pdb_path)
except IOError, e:
print "[Error] %s: %s" % (str(e), pdb_path)
## or get TLS groups from REFMAC TLSOUT file
else:
tls_file.set_file_format(TLS.TLSFileFormatTLSOUT())
try:
tls_file.load(open(tls_out_path, "r"), tls_out_path)
except IOError, e:
print "[Error] %s: %s" % (str(e), tls_out_path)
## print the TLS groups
tls_group_list = tls_file.construct_tls_groups_with_atoms(struct)
for tls_group in tls_group_list:
print_TLSGroup(tls_group)
print
if __name__ == "__main__":
def raster3d_render_tls_graph_path(self, chain, cpartition):
"""Render TLS visualizations using Raster3D.
"""
basename = "%s_CHAIN%s_NTLS%d" % (self.struct_id, chain.chain_id,
cpartition.num_tls_segments())
png_path = "%s.png" % (basename)
console.stdoutln("Raster3D: rendering %s..." % (basename))
struct_id = self.struct_id
driver = R3DDriver.Raster3DDriver()
## XXX: Size hack: some structures have too many chains,
## or are just too large
show_chain = {}
for chx in self.struct.iter_chains():
if chx.chain_id == chain.chain_id:
show_chain[chx.chain_id] = True
continue
if chx.count_amino_acids() >= 100:
show_chain[chx.chain_id] = False
continue
show_chain[chx.chain_id] = True
## end size hack
## got target chain?
if self.tlsmd_analysis.target_chain != None:
for atm in self.tlsmd_analysis.target_chain.iter_all_atoms():
atm.orig_position = atm.position
atm.position = chain.target_chain_sresult.transform(
atm.position)
viewer = Viewer.GLViewer()
gl_struct = viewer.glv_add_struct(self.struct)
## orient the structure with the super-spiffy orientation algorithm
## which hilights the chain we are examining
ori = calc_orientation(self.struct, chain)
viewer.glo_update_properties(R=ori["R"],
cor=ori["centroid"],
zoom=ori["hzoom"],
near=ori["near"],
far=ori["far"],
width=ori["pwidth"],
height=ori["pheight"],
bg_color="White")
## turn off axes and unit cell visualization
gl_struct.glo_update_properties_path("gl_axes/visible", False)
gl_struct.glo_update_properties_path("gl_unit_cell/visible", False)
## setup base structural visualization
for gl_chain in gl_struct.glo_iter_children():
if not isinstance(gl_chain, Viewer.GLChain):
continue
## chain is hidden
if show_chain.get(gl_chain.chain.chain_id, False) == False:
gl_chain.properties.update(visible=False)
continue
if gl_chain.chain.chain_id == chain.chain_id:
if gl_chain.chain.has_amino_acids():
gl_chain.properties.update(lines=False,
trace=True,
trace_radius=0.25,
trace_color="0.80,0.80,0.80")
elif gl_chain.chain.has_nucleic_acids():
gl_chain.properties.update(lines=False,
ball_stick=True,
ball_stick_radius=0.25,
color="0.80,0.80,0.80")
else:
if gl_chain.chain.has_amino_acids():
gl_chain.properties.update(lines=False,
trace=True,
trace_radius=0.25,
trace_color="0.80,0.80,0.80")
elif gl_chain.chain.has_nucleic_acids():
gl_chain.properties.update(hetatm_visible=True,
trace=True,
trace_radius=0.35,
trace_color="0.80,0.80,0.80",
ball_stick=True,
ball_stick_radius=0.25,
color="0.60,0.60,0.70")
else:
gl_chain.properties.update(visible=True,
ball_stick=True,
ball_stick_radius=0.25,
cpk=False)
## add the TLS group visualizations
has_amino_acids = cpartition.chain.has_amino_acids()
has_nucleic_acids = cpartition.chain.has_nucleic_acids()
for tls in cpartition.iter_tls_segments():
if tls.method != "TLS":
continue
if self.tlsmd_analysis.target_chain is not None:
if tls.rmsd_pre_alignment <= 0.8:
continue
if (tls.rmsd_pre_alignment - tls.sresult.rmsd) < 0.5:
continue
tls_name = "TLS_%s" % (tls.filename_label())
gl_tls_group = TLS.GLTLSGroup(oatm_visible=False,
side_chain_visible=False,
hetatm_visible=True,
adp_prob=settings.ADP_PROB,
L_axis_scale=2.0,
L_axis_radius=0.20,
both_phases=True,
tls_group=tls.tls_group,
tls_info=tls.model_tls_info,
tls_name=tls_name,
tls_color=tls.color.name)
gl_struct.glo_add_child(gl_tls_group)
if tls.superposition_vscrew != None:
gl_tls_group.properties.update(
COR_vector=tls.superposition_vscrew)
## set width of trace according to the group's translationral tensor trace
mtls_info = tls.model_tls_info
tiso = (mtls_info["Tr1_eigen_val"] + mtls_info["Tr2_eigen_val"] +
mtls_info["Tr3_eigen_val"]) / 3.0
## too big usually for good visualization -- cheat and scale it down
radius = 0.30
if has_amino_acids:
gl_tls_group.gl_atom_list.properties.update(
trace_radius=radius)
elif has_nucleic_acids:
gl_tls_group.gl_atom_list.properties.update(
oatm_visible=True,
side_chain_visible=True,
trace=True,
trace_radius=0.25,
ball_stick=True,
ball_stick_radius=radius)
gl_tls_group.glo_update_properties(time=0.25)
## got target chain?
if self.tlsmd_analysis.target_chain is not None:
gl_chain = Viewer.GLChain(chain=self.tlsmd_analysis.target_chain)
gl_chain.properties.update(oatm_visible=False,
side_chain_visible=False,
hetatm_visible=True,
lines=False,
ball_stick=False,
trace=True,
trace_radius=0.25,
trace_color="0.40,0.40,0.40")
gl_struct.glo_add_child(gl_chain)
driver.glr_set_render_png_path(png_path)
viewer.glv_render_one(driver)
## got target chain?
if self.tlsmd_analysis.target_chain != None:
for atm in self.tlsmd_analysis.target_chain.iter_all_atoms():
atm.position = atm.orig_position
del atm.orig_position
return "", png_path
def make_script(self):
console.debug_stdoutln(">gnuplots.py->UIso_vs_UtlsIso_Histogram()")
tls = self.tls
## generate data and png paths
basename = "%s_CHAIN%s_TLS%s_BoBc" % (self.chain.struct.structure_id, self.chain.chain_id, tls.filename_label())
self.set_basename(basename)
## write out the data file
tls_group = tls.tls_group
T = tls_group.itls_T
L = tls_group.itls_L
S = tls_group.itls_S
O = tls_group.origin
## create a histogram of (Uiso - Utls_iso)
bdiff_min = 0.0
bdiff_max = 0.0
for atm in tls_group:
b_iso_tls = Constants.U2B * TLS.calc_itls_uiso(T, L, S, atm.position - O)
bdiff = atm.temp_factor - b_iso_tls
bdiff_min = min(bdiff_min, bdiff)
bdiff_max = max(bdiff_max, bdiff)
## compute the bin width and range to bin over
brange = (bdiff_max - bdiff_min) + 2.0
num_bins = int(brange)
bin_width = brange / float(num_bins)
bins = [0 for n in xrange(num_bins)]
## name the bins with their mean value
bin_names = []
for n in xrange(num_bins):
bin_mean = bdiff_min + (float(n) * bin_width) + (bin_width / 2.0)
bin_names.append(bin_mean)
## count the bins
for atm in tls_group:
b_iso_tls = Constants.U2B * TLS.calc_itls_uiso(T, L, S, atm.position - O)
bdiff = atm.temp_factor - b_iso_tls
bin = int((bdiff - bdiff_min) / bin_width)
bins[bin] += 1
## write out the gnuplot input file
fil = open(self.txt_path, "w")
fil.write("## Histogram of atoms in the TLS group binned by\n")
fil.write("## the difference of their isotropic temperature factors\n")
fil.write("## from the isotropic values predicted from the TLS model.\n")
fil.write("##\n")
fil.write("## Structure ----------------: %s\n" % (self.chain.struct.structure_id))
fil.write("## Chain --------------------: %s\n" % (self.chain.chain_id))
fil.write("## TLS Group Residue Range --: %s\n" % (tls.display_label()))
job_dir = os.path.join(conf.TLSMD_WORK_DIR, conf.globalconf.job_id, "ANALYSIS")
if os.path.basename(os.getcwd()) != "ANALYSIS":
flatfile = open("../%s.dat" % conf.globalconf.job_id, "a+")
else:
flatfile = open("%s.dat" % conf.globalconf.job_id, "a+")
flatfile.write("\nCCCC UIso_vs_UtlsIso_Histogram\n")
flatfile.write("%s %s,%s.0 <DATA>\n" % ("UVUH", self.chain.chain_id, self.cpartition.num_tls_segments()))
for i in xrange(len(bins)):
fil.write("%f %d\n" % (bin_names[i], bins[i]))
flatfile.write("%f %d\n" % (bin_names[i], bins[i]))
flatfile.write("%s %s,%s.0 </DATA>\n" % ("UVUH", self.chain.chain_id, self.cpartition.num_tls_segments()))
flatfile.close()
fil.close()
## modify script template
script = _UISO_VS_UTLSISO_HISTOGRAM_TEMPLATE
script = script.replace("<txtfile>", self.txt_path)
title = "Histogram of Observed B_{iso} - B_{tls} for TLS Group %s" % (tls.display_label())
script = script.replace("<title>", title)
script = script.replace("<rgb>", tls.color.rgbs)
flat_script = script.replace("\n", ";")
flatfile_write(
"UIso_vs_UtlsIso_Histogram: script",
"UVUH",
"SCRIPT",
flat_script,
self.chain.chain_id,
self.cpartition.num_tls_segments(),
)
return script
