def exercise_select_crystal_symmetry():
xs1 = crystal.symmetry(unit_cell="23,30,40,90,90,90",
space_group="P212121")
xs2 = crystal.symmetry(unit_cell="20,30,40,90,90,90", space_group="P222")
resulting_symmetry = crystal.select_crystal_symmetry(
from_command_line=None,
from_parameter_file=None,
from_coordinate_files=[xs1],
from_reflection_files=[xs2])
assert list(xs2.unit_cell().parameters()) == list(
resulting_symmetry.unit_cell().parameters())
resulting_symmetry = crystal.select_crystal_symmetry(
from_command_line=None,
from_parameter_file=None,
from_coordinate_files=[xs2],
from_reflection_files=[xs1])
assert list(xs1.unit_cell().parameters()) == list(
resulting_symmetry.unit_cell().parameters())
resulting_symmetry = None
try:
resulting_symmetry = crystal.select_crystal_symmetry(
from_command_line=None,
from_parameter_file=None,
from_coordinate_files=[None],
from_reflection_files=[None])
except AssertionError as e:
assert str(e) == "No unit cell and symmetry information supplied"
else:
raise Exception_expected
def compute_map(self):
log = sys.stderr
# the mtz and pdb files are self.mtz_file self.pdb_file, respectively
#out = maps.run(args = [self.pdb_file, self.mtz_file])
#self.map_coeff_file, self.xplor_maps = out[0],out[1]
master_params = mmtbx.maps.maps_including_IO_master_params()
master_params = master_params.fetch(iotbx.phil.parse(default_params))
processed_args = mmtbx.utils.process_command_line_args(
args=[self.mtz_file, self.pdb_file],
log=log,
master_params=master_params)
working_phil = processed_args.params
params = working_phil.extract()
if params.maps.input.pdb_file_name is None:
params.maps.input.pdb_file_name = self.pdb_file
if params.maps.input.reflection_data.file_name is None:
params.maps.input.reflection_data.file_name = self.mtz_file
pdb_inp = iotbx.pdb.input(file_name=params.maps.input.pdb_file_name)
# get all crystal symmetries
cs_from_coordinate_files = [pdb_inp.crystal_symmetry_from_cryst1()]
csa = crystal_symmetry_from_any.extract_from(
params.maps.input.reflection_data.file_name)
cs_from_reflection_files = [csa]
crystal_symmetry = None
try:
crystal_symmetry = crystal.select_crystal_symmetry(
from_coordinate_files=cs_from_coordinate_files,
from_reflection_files=cs_from_reflection_files)
except AssertionError, e:
if ("No unit cell and symmetry information supplied" in str(e)):
raise Sorry(
"Missing or incomplete symmetry information. This program "
+
"will only work with reflection file formats that contain both "
+ "unit cell and space group records, such as MTZ files.")
def compute_map(self) :
log = sys.stderr
# the mtz and pdb files are self.mtz_file self.pdb_file, respectively
#out = maps.run(args = [self.pdb_file, self.mtz_file])
#self.map_coeff_file, self.xplor_maps = out[0],out[1]
master_params = mmtbx.maps.maps_including_IO_master_params()
master_params = master_params.fetch(iotbx.phil.parse(default_params))
processed_args = mmtbx.utils.process_command_line_args(
args=[self.mtz_file, self.pdb_file],
log=log,
master_params=master_params)
working_phil = processed_args.params
params = working_phil.extract()
if params.maps.input.pdb_file_name is None :
params.maps.input.pdb_file_name = self.pdb_file
if params.maps.input.reflection_data.file_name is None :
params.maps.input.reflection_data.file_name = self.mtz_file
pdb_inp = iotbx.pdb.input(file_name = params.maps.input.pdb_file_name)
# get all crystal symmetries
cs_from_coordinate_files = [pdb_inp.crystal_symmetry_from_cryst1()]
csa =crystal_symmetry_from_any.extract_from(params.maps.input.reflection_data.file_name)
cs_from_reflection_files = [csa]
crystal_symmetry = None
try :
crystal_symmetry = crystal.select_crystal_symmetry(
from_coordinate_files=cs_from_coordinate_files,
from_reflection_files=cs_from_reflection_files)
except AssertionError, e :
if ("No unit cell and symmetry information supplied" in str(e)) :
raise Sorry("Missing or incomplete symmetry information. This program "+
"will only work with reflection file formats that contain both "+
"unit cell and space group records, such as MTZ files.")
def _resolve_symmetry_conflicts(self,
model,
reflection_file_server,
params=None):
'''
Use logic of crystal.select_crystal_symmetry to select consensus crystal
symmetry from multiple sources.
'''
if (reflection_file_server is None): return
crystal_symmetries_from_coordinate_file = []
crystal_symmetries_from_reflection_file = []
rfns = []
rfns.extend(reflection_file_server.file_name_miller_arrays.keys())
crystal_symmetry_from_any.extract_and_append(
file_names=rfns,
target_list=crystal_symmetries_from_reflection_file)
crystal_symmetries_from_coordinate_file.append(
model.crystal_symmetry())
from_parameter_file = None
if (params is not None):
from_parameter_file = crystal.symmetry(
unit_cell=params.unit_cell,
space_group_info=params.space_group)
crystal_symmetry = crystal.select_crystal_symmetry(
from_parameter_file=from_parameter_file,
from_coordinate_files=crystal_symmetries_from_coordinate_file,
from_reflection_files=crystal_symmetries_from_reflection_file)
model.set_crystal_symmetry(crystal_symmetry=crystal_symmetry)
if (reflection_file_server.crystal_symmetry is None
or not crystal_symmetry.is_similar_symmetry(
reflection_file_server.crystal_symmetry)):
reflection_file_server.update_crystal_symmetry(
crystal_symmetry=model.crystal_symmetry())
def exercise_select_crystal_symmetry():
xs1 = crystal.symmetry(unit_cell = "23,30,40,90,90,90",
space_group = "P212121" )
xs2 = crystal.symmetry(unit_cell = "20,30,40,90,90,90",
space_group = "P222" )
resulting_symmetry = crystal.select_crystal_symmetry( from_command_line = None,
from_parameter_file = None,
from_coordinate_files = [xs1],
from_reflection_files = [xs2] )
assert list( xs2.unit_cell().parameters() ) == list( resulting_symmetry.unit_cell().parameters() )
resulting_symmetry = crystal.select_crystal_symmetry( from_command_line = None,
from_parameter_file = None,
from_coordinate_files = [xs2],
from_reflection_files = [xs1] )
assert list( xs1.unit_cell().parameters() ) == list( resulting_symmetry.unit_cell().parameters() )
resulting_symmetry = None
try:
resulting_symmetry = crystal.select_crystal_symmetry( from_command_line = None,
from_parameter_file = None,
from_coordinate_files = [None],
from_reflection_files = [None] )
except AssertionError ,e :
assert str(e)=="No unit cell and symmetry information supplied"
def run(args, command_name="phenix.twin_map_utils"):
log = sys.stdout
params = None
if (len(args) == 0 or "--help" in args or "--h" in args or "-h" in args):
print_help(command_name=command_name)
else:
log = multi_out()
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="map_coefs")
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
if not arg_is_processed:
print("##----------------------------------------------##",
file=log)
print("## Unknown file or keyword:", arg, file=log)
print("##----------------------------------------------##",
file=log)
print(file=log)
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params = effective_params.extract()
"""
new_params = master_params.format(python_object=params)
new_params.show(out=log)
"""
# now get the unit cell from the pdb file
hkl_xs = crystal_symmetry_from_any.extract_from(
file_name=params.twin_utils.input.xray_data.file_name)
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.twin_utils.input.model.file_name)
phil_xs = None
if ([
params.twin_utils.input.unit_cell,
params.twin_utils.input.space_group
]).count(None) < 2:
phil_xs = crystal.symmetry(
unit_cell=params.twin_utils.input.unit_cell,
space_group_info=params.twin_utils.input.space_group)
combined_xs = crystal.select_crystal_symmetry(None, phil_xs, [pdb_xs],
[hkl_xs])
# inject the unit cell and symmetry in the phil scope please
params.twin_utils.input.unit_cell = combined_xs.unit_cell()
params.twin_utils.input.space_group = \
sgtbx.space_group_info( group = combined_xs.space_group() )
new_params = master_params.format(python_object=params)
new_params.show(out=log)
if params.twin_utils.input.unit_cell is None:
raise Sorry("unit cell not specified")
if params.twin_utils.input.space_group is None:
raise Sorry("space group not specified")
if params.twin_utils.input.xray_data.file_name is None:
raise Sorry("Xray data not specified")
if params.twin_utils.input.model.file_name is None:
raise Sorry("pdb file with model not specified")
#-----------------------------------------------------------
#
# step 1: read in the reflection file
#
phil_xs = crystal.symmetry(
unit_cell=params.twin_utils.input.unit_cell,
space_group_info=params.twin_utils.input.space_group)
xray_data_server = reflection_file_utils.reflection_file_server(
crystal_symmetry=phil_xs, force_symmetry=True, reflection_files=[])
miller_array = None
free_flags = None
tmp_params = utils.data_and_flags_master_params().extract()
# insert proper values please
tmp_params.file_name = params.twin_utils.input.xray_data.file_name
tmp_params.labels = params.twin_utils.input.xray_data.obs_labels
tmp_params.r_free_flags.file_name = params.twin_utils.input.xray_data.file_name
tmp_params.r_free_flags.label = params.twin_utils.input.xray_data.free_flag
tmp_object = utils.determine_data_and_flags(
reflection_file_server=xray_data_server,
parameters=tmp_params,
log=log)
miller_array = tmp_object.extract_data()
if miller_array.is_xray_intensity_array():
miller_array = miller_array.f_sq_as_f()
assert miller_array.is_xray_amplitude_array()
free_flags = tmp_object.extract_flags(data=miller_array)
print(file=log)
print("Attempting to extract Free R flags", file=log)
free_flags = free_flags.customized_copy(data=flex.bool(
free_flags.data() == 1))
if free_flags is None:
free_flags = miller_array.generate_r_free_flags(
use_lattice_symmetry=True)
assert miller_array.observation_type() is not None
print(file=log)
print("Summary info of observed data", file=log)
print("=============================", file=log)
miller_array.show_summary(f=log)
print(file=log)
if miller_array.indices().size() == 0:
raise Sorry("No data available")
#----------------------------------------------------------------
# Step 2: get an xray structure from the PDB file
#
model = pdb.input(file_name=params.twin_utils.input.model.file_name
).xray_structure_simple(crystal_symmetry=phil_xs)
print("Atomic model summary", file=log)
print("====================", file=log)
model.show_summary(f=log)
print(file=log)
#----------------------------------------------------------------
# step 3: get the twin laws for this xs
twin_laws = twin_analyses.twin_laws(
miller_array,
lattice_symmetry_max_delta=\
params.twin_utils.parameters.twinning.max_delta,
out=log)
print(file=log)
print("Preliminary data analyses", file=log)
print("==========================", file=log)
twin_laws.show(out=log)
#---------
# step 3:
# make twin model managers for all twin laws
print(file=log)
print(
"Overall and bulk solvent scale paranmeters and twin fraction estimation",
file=log)
print(
"=======================================================================",
file=log)
twin_models = []
operator_count = 0
if params.twin_utils.parameters.twinning.twin_law is not None:
tmp_law = sgtbx.rt_mx(
params.twin_utils.parameters.twinning.twin_law)
tmp_law = twin_analyses.twin_law(tmp_law, None, None, None, None,
None)
twin_laws.operators = [tmp_law]
for twin_law in twin_laws.operators:
operator_count += 1
operator_hkl = sgtbx.change_of_basis_op(twin_law.operator).as_hkl()
twin_model = twin_f_model.twin_model_manager(
f_obs=miller_array,
r_free_flags=free_flags,
xray_structure=model,
twin_law=twin_law.operator,
detwin_mode=params.twin_utils.parameters.twinning.detwin_mode,
out=log)
print("--- bulk solvent scaling ---", file=log)
twin_model.update_all_scales()
twin_model.r_values()
twin_model.target()
twin_model.show_k_sol_b_sol_b_cart_target()
twin_model.show_essential()
wfofc = twin_model.map_coefficients(map_type="mFo-DFc")
wtfofc = twin_model.map_coefficients(map_type="2mFo-DFc")
grad = twin_model.map_coefficients(map_type="gradient")
mtz_dataset = wtfofc.as_mtz_dataset(column_root_label="FWT")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array=wfofc, column_root_label="DFWT")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array=grad, column_root_label="GRAD")
name = params.twin_utils.output.map_coeffs_root + "_" + str(
operator_count) + ".mtz"
print(file=log)
print("Writing %s for twin law %s" % (name, operator_hkl),
file=log)
print(file=log)
mtz_dataset.mtz_object().write(file_name=name)
if params.twin_utils.output.obs_and_calc is not None:
# i want also a Fobs and Fmodel combined dataset please
mtz_dataset = miller_array.as_mtz_dataset(
column_root_label="FOBS")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array=twin_model.f_model(),
column_root_label="FMODEL")
name = params.twin_utils.output.obs_and_calc
mtz_dataset.mtz_object().write(file_name=name)
if len(twin_laws.operators) == 0:
print(file=log)
print("No twin laws were found", file=log)
print("Performing maximum likelihood based bulk solvent scaling",
file=log)
f_model_object = f_model.manager(f_obs=miller_array,
r_free_flags=free_flags,
xray_structure=model)
f_model_object.update_all_scales(log=log)
tfofc = f_model_object.map_coefficients(map_type="2mFobs-DFmodel")
fofc = f_model_object.map_coefficients(map_type="mFobs-DFmodel")
mtz_dataset = tfofc.as_mtz_dataset(column_root_label="FWT")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array=fofc, column_root_label="DELFWT")
name = params.twin_utils.output.map_coeffs_root + "_ML.mtz"
mtz_dataset.mtz_object().write(file_name=name)
if params.twin_utils.output.obs_and_calc is not None:
# i want also a Fobs and Fmodel combined dataset please
mtz_dataset = miller_array.as_mtz_dataset(
column_root_label="FOBS")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array=f_model_object.f_model(),
column_root_label="FMODEL")
name = params.twin_utils.output.obs_and_calc
mtz_dataset.mtz_object().write(file_name=name)
print(file=log)
print(file=log)
print("All done \n", file=log)
logfile = open(params.twin_utils.output.logfile, 'w')
print(string_buffer.getvalue(), file=logfile)
print(file=log)
def run(args, command_name="phenix.remove_outliers"):
if (len(args)==0 or "--help" in args or "--h" in args or "-h" in args):
print_help(command_name=command_name)
else:
log = multi_out()
plot_out = None
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="outlier_detection")
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if arg=="--quiet":
arg_is_processed = True
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
if not arg_is_processed:
print >> log, "##----------------------------------------------##"
print >> log, "## Unknown file or keyword:", arg
print >> log, "##----------------------------------------------##"
print >> log
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params = effective_params.extract()
if not os.path.exists( params.outlier_utils.input.xray_data.file_name ) :
raise Sorry("File %s can not be found"%(params.outlier_utils.input.xray_data.file_name) )
if params.outlier_utils.input.model.file_name is not None:
if not os.path.exists( params.outlier_utils.input.model.file_name ):
raise Sorry("File %s can not be found"%(params.outlier_utils.input.model.file_name) )
# now get the unit cell from the pdb file
hkl_xs = None
if params.outlier_utils.input.xray_data.file_name is not None:
hkl_xs = crystal_symmetry_from_any.extract_from(
file_name=params.outlier_utils.input.xray_data.file_name)
pdb_xs = None
if params.outlier_utils.input.model.file_name is not None:
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.outlier_utils.input.model.file_name)
phil_xs = crystal.symmetry(
unit_cell=params.outlier_utils.input.unit_cell,
space_group_info=params.outlier_utils.input.space_group )
phil_xs.show_summary()
hkl_xs.show_summary()
combined_xs = crystal.select_crystal_symmetry(
None,phil_xs, [pdb_xs],[hkl_xs])
# inject the unit cell and symmetry in the phil scope please
params.outlier_utils.input.unit_cell = combined_xs.unit_cell()
params.outlier_utils.input.space_group = \
sgtbx.space_group_info( group = combined_xs.space_group() )
new_params = master_params.format(python_object=params)
new_params.show(out=log)
if params.outlier_utils.input.unit_cell is None:
raise Sorry("unit cell not specified")
if params.outlier_utils.input.space_group is None:
raise Sorry("space group not specified")
if params.outlier_utils.input.xray_data.file_name is None:
raise Sorry("Xray data not specified")
if params.outlier_utils.input.model.file_name is None:
print "PDB file not specified. Basic wilson outlier rejections only."
#-----------------------------------------------------------
#
# step 1: read in the reflection file
#
phil_xs = crystal.symmetry(
unit_cell=params.outlier_utils.input.unit_cell,
space_group_info=params.outlier_utils.input.space_group )
xray_data_server = reflection_file_utils.reflection_file_server(
crystal_symmetry = phil_xs,
force_symmetry = True,
reflection_files=[])
miller_array = None
miller_array = xray_data_server.get_xray_data(
file_name = params.outlier_utils.input.xray_data.file_name,
labels = params.outlier_utils.input.xray_data.obs_labels,
ignore_all_zeros = True,
parameter_scope = 'outlier_utils.input.xray_data',
parameter_name = 'obs_labels'
)
info = miller_array.info()
miller_array = miller_array.map_to_asu()
miller_array = miller_array.select(
miller_array.indices() != (0,0,0))
#we have to check if the sigma's make any sense at all
if not miller_array.sigmas_are_sensible():
miller_array = miller_array.customized_copy(
data = miller_array.data(),
sigmas=None).set_observation_type(miller_array)
miller_array = miller_array.select(
miller_array.data() > 0 )
if miller_array.sigmas() is not None:
miller_array = miller_array.select(
miller_array.sigmas() > 0 )
if (miller_array.is_xray_intensity_array()):
miller_array = miller_array.f_sq_as_f()
elif (miller_array.is_complex_array()):
miller_array = abs(miller_array)
miller_array.set_info(info)
merged_anomalous=False
if miller_array.anomalous_flag():
miller_array = miller_array.average_bijvoet_mates().set_observation_type(
miller_array )
merged_anomalous=True
miller_array = miller_array.map_to_asu()
# get the free reflections please
free_flags = None
if params.outlier_utils.input.xray_data.free_flags is None:
free_flags = miller_array.generate_r_free_flags(
fraction=params.outlier_utils.\
additional_parameters.free_flag_generation.fraction,
max_free=params.outlier_utils.\
additional_parameters.free_flag_generation.max_number,
lattice_symmetry_max_delta=params.outlier_utils.\
additional_parameters.free_flag_generation.lattice_symmetry_max_delta,
use_lattice_symmetry=params.outlier_utils.\
additional_parameters.free_flag_generation.use_lattice_symmetry
)
else:
free_flags = xray_data_server.get_xray_data(
file_name = params.outlier_utils.input.xray_data.file_name,
labels = params.outlier_utils.input.xray_data.free_flags,
ignore_all_zeros = True,
parameter_scope = 'outlier_utils.input.xray_data',
parameter_name = 'free_flags'
)
if free_flags.anomalous_flag():
free_flags = free_flags.average_bijvoet_mates()
merged_anomalous=True
free_flags = free_flags.customized_copy(
data = flex.bool( free_flags.data() == 1 ))
free_flags = free_flags.map_to_asu()
free_flags = free_flags.common_set( miller_array )
print >> log
print >> log, "Summary info of observed data"
print >> log, "============================="
miller_array.show_summary(f=log)
if merged_anomalous:
print >> log, "For outlier detection purposes, the Bijvoet pairs have been merged."
print >> log
print >> log, "Constructing an outlier manager"
print >> log, "==============================="
print >> log
outlier_manager = outlier_rejection.outlier_manager(
miller_array,
free_flags,
out=log)
basic_array = None
extreme_array = None
model_based_array = None
basic_array = outlier_manager.basic_wilson_outliers(
p_basic_wilson = params.outlier_utils.outlier_detection.\
parameters.basic_wilson.level,
return_data = True)
extreme_array = outlier_manager.extreme_wilson_outliers(
p_extreme_wilson = params.outlier_utils.outlier_detection.parameters.\
extreme_wilson.level,
return_data = True)
beamstop_array = outlier_manager.beamstop_shadow_outliers(
level = params.outlier_utils.outlier_detection.parameters.\
beamstop.level,
d_min = params.outlier_utils.outlier_detection.parameters.\
beamstop.d_min,
return_data=True)
#----------------------------------------------------------------
# Step 2: get an xray structure from the PDB file
#
if params.outlier_utils.input.model.file_name is not None:
model = pdb.input(file_name=params.outlier_utils.input.model.file_name).xray_structure_simple(
crystal_symmetry=phil_xs)
print >> log, "Atomic model summary"
print >> log, "===================="
model.show_summary(f=log)
print >> log
# please make an f_model object for bulk solvent scaling etc etc
f_model_object = f_model.manager(
f_obs = miller_array,
r_free_flags = free_flags,
xray_structure = model )
print >> log, "Bulk solvent scaling of the data"
print >> log, "================================"
print >> log, "Maximum likelihood bulk solvent scaling."
print >> log
f_model_object.update_solvent_and_scale(out=log)
plot_out = StringIO()
model_based_array = outlier_manager.model_based_outliers(
f_model_object.f_model(),
level=params.outlier_utils.outlier_detection.parameters.model_based.level,
return_data=True,
plot_out=plot_out)
#check what needs to be put out please
if params.outlier_utils.output.hklout is not None:
if params.outlier_utils.outlier_detection.protocol == "model":
if params.outlier_utils.input.model.file_name == None:
print >> log, "Model based rejections requested. No model was supplied."
print >> log, "Switching to writing out rejections based on extreme value Wilson statistics."
params.outlier_utils.outlier_detection.protocol="extreme"
output_array = None
print >> log
if params.outlier_utils.outlier_detection.protocol == "basic":
print >> log, "Non-outliers found by the basic wilson statistics"
print >> log, "protocol will be written out."
output_array = basic_array
new_set_of_free_flags = free_flags.common_set( basic_array )
if params.outlier_utils.outlier_detection.protocol == "extreme":
print >> log, "Non-outliers found by the extreme value wilson statistics"
print >> log, "protocol will be written out."
output_array = extreme_array
new_set_of_free_flags = free_flags.common_set( extreme_array )
if params.outlier_utils.outlier_detection.protocol == "model":
print >> log, "Non-outliers found by the model based"
print >> log, "protocol will be written out to the file:"
print >> log, params.outlier_utils.output.hklout
print >> log
output_array = model_based_array
new_set_of_free_flags = free_flags.common_set( model_based_array )
if params.outlier_utils.outlier_detection.protocol == "beamstop":
print >> log, "Outliers found for the beamstop shadow"
print >> log, "problems detection protocol will be written to the file:"
print >> log, params.outlier_utils.output.hklout
print >> log
output_array = model_based_array
new_set_of_free_flags = free_flags.common_set( model_based_array )
mtz_dataset = output_array.as_mtz_dataset(
column_root_label="FOBS")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array = new_set_of_free_flags,
column_root_label = "Free_R_Flag"
)
mtz_dataset.mtz_object().write(
file_name=params.outlier_utils.output.hklout)
if (params.outlier_utils.output.logfile is not None):
final_log = StringIO()
print >> final_log, string_buffer.getvalue()
print >> final_log
if plot_out is not None:
print >> final_log, plot_out.getvalue()
outfile = open( params.outlier_utils.output.logfile, 'w' )
outfile.write( final_log.getvalue() )
print >> log
print >> log, "A logfile named %s was created."%(
params.outlier_utils.output.logfile)
print >> log, "This logfile contains the screen output and"
print >> log, "(possibly) some ccp4 style loggraph plots"
def get_reflection_file_server(self,
filenames=None,
labels=None,
crystal_symmetry=None,
force_symmetry=None):
'''
Return the file server for a single miller_array file or mulitple files
:param filenames: list of filenames or None
:param labels: list of lists of labels or None
:param crystal_symmetry: cctbx.crystal.symmetry object or None
:param force_symmetry: bool or None
The order in filenames and labels should match, e.g. labels[0] should be the
labels for filenames[0]. The lengths of filenames and labels should be equal
as well. If all the labels in a file are to be added, set the labels entry
to None, e.g. labels[0] = None.
'''
# use default miller_array file if no filenames provided
if (filenames is None):
default_filename = self._check_miller_array_default_filename(
'miller_array')
filenames = [default_filename]
# set labels
if (labels is None):
labels = [None for filename in filenames]
assert (len(filenames) == len(labels))
# force crystal symmetry if a crystal symmetry is provided
if ((crystal_symmetry is not None) and (force_symmetry is None)):
force_symmetry = True
if (force_symmetry is None):
force_symmetry = False
# determine crystal symmetry from file list, if not provided
if (crystal_symmetry is None):
try:
from_reflection_files = list()
for filename, file_labels in zip(filenames, labels):
miller_arrays = self.get_miller_arrays(filename=filename)
for miller_array in miller_arrays:
if ((file_labels is None)
or (miller_array.info().label_string()
in file_labels)):
from_reflection_files.append(
miller_array.crystal_symmetry())
crystal_symmetry = crystal.select_crystal_symmetry(
from_reflection_files=from_reflection_files)
except Exception:
raise Sorry(
'A unit cell and space group could not be determined from the "filenames" argument. Please provide a list of filenames.'
)
# crystal_symmetry and force_symmetry should be set by now
miller_arrays = list()
for filename, file_labels in zip(filenames, labels):
file_arrays = self.get_miller_array(filename=filename).\
as_miller_arrays(crystal_symmetry=crystal_symmetry,
force_symmetry=force_symmetry)
for miller_array in file_arrays:
if ((file_labels is None) or
(miller_array.info().label_string() in file_labels)):
miller_arrays.append(miller_array)
file_server = reflection_file_server(crystal_symmetry=crystal_symmetry,
force_symmetry=force_symmetry,
miller_arrays=miller_arrays)
return file_server
def run(args,
log=sys.stdout,
use_output_directory=True,
suppress_fmodel_output=False):
print(legend, file=log)
print("-" * 79, file=log)
master_params = mmtbx.maps.maps_including_IO_master_params()
if (len(args) == 0 or (len(args) == 1 and args[0] == "NO_PARAMETER_FILE")):
if (not (len(args) == 1 and args[0] == "NO_PARAMETER_FILE")):
parameter_file_name = "maps.params"
print(
"Creating parameter file '%s' in the following directory:\n%s"
% (parameter_file_name, os.path.abspath('.')),
file=log)
if (os.path.isfile(parameter_file_name)):
msg = "File '%s' exists already. Re-name it or move and run the command again."
raise Sorry(msg % parameter_file_name)
pfo = open(parameter_file_name, "w")
else:
pfo = log
print("\nAll phenix.maps parameters::\n", file=pfo)
master_params = master_params.fetch(iotbx.phil.parse(default_params))
master_params.show(out=pfo, prefix=" ", expert_level=1)
return
processed_args = mmtbx.utils.process_command_line_args(
args=args, log=log, master_params=master_params)
working_phil = processed_args.params
params = working_phil.extract()
fmodel_data_file_format = params.maps.output.fmodel_data_file_format
if (len(params.maps.map_coefficients) == 0) and (len(params.maps.map)
== 0):
print("No map input specified - using default map types", file=log)
working_phil = master_params.fetch(
sources=[working_phil,
iotbx.phil.parse(default_params)])
params = working_phil.extract()
# XXX BUG - the extra fetch will always set fmodel_data_file_format to
# mtz; this is probaby a low-level phil problem
if (fmodel_data_file_format is None) or (suppress_fmodel_output):
params.maps.output.fmodel_data_file_format = None
analyze_input_params(params=params)
have_phil_file_input = len(processed_args.phil_file_names) > 0
if (len(processed_args.pdb_file_names) > 1):
raise Sorry("Only one model file is allowed as input.")
if ((params.maps.input.pdb_file_name is None)
and (len(processed_args.pdb_file_names) == 1)):
params.maps.input.pdb_file_name = processed_args.pdb_file_names[0]
if (not os.path.isfile(str(params.maps.input.pdb_file_name))):
raise Sorry(
"model file is not given: maps.input.pdb_file_name=%s is not a file"%\
str(params.maps.input.pdb_file_name))
if ((params.maps.input.reflection_data.file_name is None) and
(params.maps.input.reflection_data.r_free_flags.file_name is None)
and (len(processed_args.reflection_file_names) == 1)):
params.maps.input.reflection_data.file_name = \
processed_args.reflection_file_names[0]
print("FORMAT:", params.maps.output.fmodel_data_file_format, file=log)
working_phil = master_params.format(python_object=params)
print("-" * 79, file=log)
print("\nParameters to compute maps::\n", file=log)
working_phil.show(out=log, prefix=" ")
pdb_inp = iotbx.pdb.input(file_name=params.maps.input.pdb_file_name)
# get all crystal symmetries
cs_from_coordinate_files = [pdb_inp.crystal_symmetry_from_cryst1()]
cs_from_reflection_files = []
for rfn in [
params.maps.input.reflection_data.file_name,
params.maps.input.reflection_data.r_free_flags.file_name
]:
if (os.path.isfile(str(rfn))):
try:
cs_from_reflection_files.append(
crystal_symmetry_from_any.extract_from(rfn))
except KeyboardInterrupt:
raise
except RuntimeError:
pass
crystal_symmetry = None
try:
crystal_symmetry = crystal.select_crystal_symmetry(
from_coordinate_files=cs_from_coordinate_files,
from_reflection_files=cs_from_reflection_files)
except AssertionError as e:
if ("No unit cell and symmetry information supplied" in str(e)):
raise Sorry(
"Missing or incomplete symmetry information. This program " +
"will only work with reflection file formats that contain both "
+ "unit cell and space group records, such as MTZ files.")
#
reflection_files = []
reflection_file_names = []
for rfn in [
params.maps.input.reflection_data.file_name,
params.maps.input.reflection_data.r_free_flags.file_name
]:
if (os.path.isfile(str(rfn))) and (not rfn in reflection_file_names):
reflection_files.append(
reflection_file_reader.any_reflection_file(
file_name=rfn, ensure_read_access=False))
reflection_file_names.append(rfn)
reflection_file_server = reflection_file_utils.reflection_file_server(
crystal_symmetry=crystal_symmetry,
force_symmetry=True,
reflection_files=reflection_files, #[],
err=log)
#
reflection_data_master_params = mmtbx.utils.data_and_flags_master_params(
master_scope_name="reflection_data")
reflection_data_input_params = processed_args.params.get(
"maps.input.reflection_data")
reflection_data_params = reflection_data_master_params.fetch(
reflection_data_input_params).extract().reflection_data
#
determine_data_and_flags_result = mmtbx.utils.determine_data_and_flags(
reflection_file_server=reflection_file_server,
parameters=reflection_data_params,
data_parameter_scope="maps.input.reflection_data",
flags_parameter_scope="maps.input.reflection_data.r_free_flags",
data_description="Reflection data",
keep_going=True,
log=log)
f_obs = determine_data_and_flags_result.f_obs
r_free_flags = determine_data_and_flags_result.r_free_flags
test_flag_value = determine_data_and_flags_result.test_flag_value
if (r_free_flags is None):
r_free_flags = f_obs.array(data=flex.bool(f_obs.data().size(), False))
test_flag_value = None
print("-" * 79, file=log)
print("\nInput model file:", params.maps.input.pdb_file_name, file=log)
pdb_hierarchy = pdb_inp.construct_hierarchy(set_atom_i_seq=True)
atom_selection_manager = pdb_hierarchy.atom_selection_cache()
xray_structure = pdb_hierarchy.extract_xray_structure(
crystal_symmetry=crystal_symmetry)
# apply omit selection
if (params.maps.omit.selection is not None):
omit_selection = atom_selection_manager.selection(
string=params.maps.omit.selection)
keep_selection = ~omit_selection
xray_structure = xray_structure.select(selection=keep_selection)
pdb_hierarchy = pdb_hierarchy.select(keep_selection)
atom_selection_manager = pdb_hierarchy.atom_selection_cache()
#
mmtbx.utils.setup_scattering_dictionaries(
scattering_table=params.maps.scattering_table,
xray_structure=xray_structure,
d_min=f_obs.d_min(),
log=log)
if (params.maps.wavelength is not None):
if (params.maps.scattering_table == "neutron"):
raise Sorry(
"Wavelength parameter not supported when the neutron " +
"scattering table is used.")
xray_structure.set_inelastic_form_factors(
photon=params.maps.wavelength, table="sasaki")
xray_structure.show_summary(f=log, prefix=" ")
print("-" * 79, file=log)
print("Bulk solvent correction and anisotropic scaling:", file=log)
fmodel = mmtbx.utils.fmodel_simple(
xray_structures=[xray_structure],
scattering_table=params.maps.scattering_table,
f_obs=f_obs,
r_free_flags=r_free_flags,
outliers_rejection=params.maps.input.reflection_data.
outliers_rejection,
skip_twin_detection=params.maps.skip_twin_detection,
bulk_solvent_correction=params.maps.bulk_solvent_correction,
anisotropic_scaling=params.maps.anisotropic_scaling)
fmodel_info = fmodel.info()
fmodel_info.show_rfactors_targets_scales_overall(out=log)
print("-" * 79, file=log)
print("Compute maps.", file=log)
# XXX if run from the Phenix GUI, the output directory parameter is actually
# one level up from the current directory, and use_output_directory=False
if (params.maps.output.directory is not None) and (use_output_directory):
assert os.path.isdir(params.maps.output.directory)
output_dir = params.maps.output.directory
else:
output_dir = os.getcwd()
if params.maps.output.prefix is not None:
file_name_base = os.path.join(
output_dir, os.path.basename(params.maps.output.prefix))
else:
file_name_base = params.maps.input.pdb_file_name
if (file_name_base.count(".") > 0):
file_name_base = file_name_base[:file_name_base.index(".")]
xplor_maps = mmtbx.maps.compute_xplor_maps(
fmodel=fmodel,
params=params.maps.map,
atom_selection_manager=atom_selection_manager,
file_name_prefix=None,
file_name_base=file_name_base,
pdb_hierarchy=pdb_hierarchy)
cmo = mmtbx.maps.compute_map_coefficients(
fmodel=fmodel,
params=params.maps.map_coefficients,
pdb_hierarchy=pdb_hierarchy,
log=log)
map_coeff_file_name = file_name_base + "_map_coeffs.mtz"
r_free_flags_output = None
if (params.maps.output.include_r_free_flags):
r_free_flags_output = fmodel.r_free_flags().average_bijvoet_mates()
write_mtz_file_result = cmo.write_mtz_file(
file_name=map_coeff_file_name, r_free_flags=r_free_flags_output)
if (params.maps.output.fmodel_data_file_format is not None):
fmodel_file_name = file_name_base + "_fmodel." + \
params.maps.output.fmodel_data_file_format
print("Writing fmodel arrays (Fobs, Fcalc, m, ...) to %s file."%\
fmodel_file_name, file=log)
fmodel_file_object = open(fmodel_file_name, "w")
fmodel.export(out=fmodel_file_object,
format=params.maps.output.fmodel_data_file_format)
fmodel_file_object.close()
print("All done.", file=log)
if (write_mtz_file_result):
print("Map coefficients: %s" % map_coeff_file_name, file=log)
for file_name in xplor_maps:
print("CCP4 or XPLOR map: %s" % file_name, file=log)
print("-" * 79, file=log)
return (map_coeff_file_name, xplor_maps)
def sfcalc(args):
if len(args) == 0:
print_help()
elif ("--help" in args):
print_help()
elif ("--h" in args):
print_help()
elif ("-h" in args):
print_help()
else:
log = multi_out()
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="sfcalc")
print("#phil __OFF__", file=log)
print("=================", file=log)
print(" SFCALC ", file=log)
print("=================", file=log)
print(file=log)
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
if not arg_is_processed:
print("##----------------------------------------------##",
file=log)
print("## Unknown file or keyword:", arg, file=log)
print("##----------------------------------------------##",
file=log)
print(file=log)
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params = effective_params.extract()
# now get the unit cell from the files
hkl_xs = None
pdb_xs = None
if params.sfcalc.input.model.file_name is not None:
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.sfcalc.input.model.file_name)
phil_xs = crystal.symmetry(
unit_cell=params.sfcalc.input.unit_cell,
space_group_info=params.sfcalc.input.space_group)
combined_xs = crystal.select_crystal_symmetry(None, phil_xs, [pdb_xs],
[None])
combined_xs.show_summary()
if combined_xs.unit_cell() is None:
raise Sorry("Unit cell not defined")
if combined_xs.space_group() is None:
raise Sorry("Space group not defined")
# inject the unit cell and symmetry in the phil scope please
params.sfcalc.input.unit_cell = combined_xs.unit_cell()
params.sfcalc.input.space_group = \
sgtbx.space_group_info( group = combined_xs.space_group() )
print("#phil __ON__", file=log)
new_params = master_params.format(python_object=params)
new_params.show(out=log)
print("#phil __END__", file=log)
pdb_model = None
if params.sfcalc.input.model.file_name is not None:
pdb_model = pdb.input(
file_name=params.sfcalc.input.model.file_name)
model = pdb_model.xray_structure_simple(crystal_symmetry=phil_xs)
print("Atomic model summary", file=log)
print("====================", file=log)
model.show_summary()
print(file=log)
#make an f_model object please
b_cart = params.sfcalc.parameters.overall.b_cart
b_cart = [
b_cart.b_11, b_cart.b_22, b_cart.b_33, b_cart.b_12,
b_cart.b_13, b_cart.b_23
]
dummy = abs(
model.structure_factors(d_min=params.sfcalc.parameters.d_min,
anomalous_flag=False).f_calc())
flags = dummy.generate_r_free_flags(fraction=0.1,
max_free=99999999)
fmodel = f_model.manager(
xray_structure=model,
r_free_flags=flags,
target_name="ls_wunit_k1",
f_obs=dummy,
b_cart=b_cart,
k_sol=params.sfcalc.parameters.solvent.k_sol,
b_sol=params.sfcalc.parameters.solvent.b_sol)
calc_data_with_solvent_contrib = fmodel.f_model()
calc_data_with_solvent_contrib = calc_data_with_solvent_contrib.array(
data=calc_data_with_solvent_contrib.data() *
params.sfcalc.parameters.overall.k_overall)
result = None
label = None
if params.sfcalc.parameters.output_type == "complex":
result = calc_data_with_solvent_contrib
label = "FMODEL"
if params.sfcalc.parameters.output_type == "amplitudes":
result = abs(calc_data_with_solvent_contrib)
label = "FMODEL"
if params.sfcalc.parameters.output_type == "intensities":
result = abs(calc_data_with_solvent_contrib)
result = result.f_as_f_sq()
label = "IMODEL"
#write an mtz file with the data
mtz_dataset = result.as_mtz_dataset(column_root_label=label)
mtz_dataset.mtz_object().write(
file_name=params.sfcalc.output.hklout)
#write the logfile
logger = open(params.sfcalc.output.logfile, 'w')
print("writing log file with name %s" % (params.sfcalc.output.logfile),
file=log)
print(file=log)
print(string_buffer.getvalue(), file=logger)
def sfcalc(args):
if len(args)==0:
print_help()
elif ( "--help" in args ):
print_help()
elif ( "--h" in args ):
print_help()
elif ("-h" in args ):
print_help()
else:
log = multi_out()
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="sfcalc")
print >> log, "#phil __OFF__"
print >> log, "================="
print >> log, " SFCALC "
print >> log, "================="
print >> log
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
if not arg_is_processed:
print >> log, "##----------------------------------------------##"
print >> log, "## Unknown file or keyword:", arg
print >> log, "##----------------------------------------------##"
print >> log
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params = effective_params.extract()
# now get the unit cell from the files
hkl_xs = None
pdb_xs = None
if params.sfcalc.input.model.file_name is not None:
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.sfcalc.input.model.file_name)
phil_xs = crystal.symmetry(
unit_cell=params.sfcalc.input.unit_cell,
space_group_info=params.sfcalc.input.space_group )
combined_xs = crystal.select_crystal_symmetry(
None,phil_xs, [pdb_xs],[None])
combined_xs.show_summary()
if combined_xs.unit_cell() is None:
raise Sorry("Unit cell not defined")
if combined_xs.space_group() is None:
raise Sorry("Space group not defined")
# inject the unit cell and symmetry in the phil scope please
params.sfcalc.input.unit_cell = combined_xs.unit_cell()
params.sfcalc.input.space_group = \
sgtbx.space_group_info( group = combined_xs.space_group() )
print >> log, "#phil __ON__"
new_params = master_params.format(python_object=params)
new_params.show(out=log)
print >> log, "#phil __END__"
pdb_model = None
if params.sfcalc.input.model.file_name is not None:
pdb_model = pdb.input(file_name=params.sfcalc.input.model.file_name)
model = pdb_model.xray_structure_simple(crystal_symmetry=phil_xs)
print >> log, "Atomic model summary"
print >> log, "===================="
model.show_summary()
print >> log
#make an f_model object please
b_cart = params.sfcalc.parameters.overall.b_cart
b_cart = [b_cart.b_11,
b_cart.b_22,
b_cart.b_33,
b_cart.b_12,
b_cart.b_13,
b_cart.b_23]
dummy = abs(model.structure_factors(
d_min = params.sfcalc.parameters.d_min,
anomalous_flag = False).f_calc())
flags = dummy.generate_r_free_flags(fraction = 0.1,
max_free = 99999999)
fmodel = f_model.manager( xray_structure = model,
r_free_flags = flags,
target_name = "ls_wunit_k1",
f_obs = dummy,
b_cart = b_cart,
k_sol = params.sfcalc.parameters.solvent.k_sol,
b_sol = params.sfcalc.parameters.solvent.b_sol )
calc_data_with_solvent_contrib = fmodel.f_model()
calc_data_with_solvent_contrib = calc_data_with_solvent_contrib.array(
data=calc_data_with_solvent_contrib.data()*params.sfcalc.parameters.overall.k_overall)
result = None
label = None
if params.sfcalc.parameters.output_type == "complex":
result = calc_data_with_solvent_contrib
label="FMODEL"
if params.sfcalc.parameters.output_type == "amplitudes":
result = abs(calc_data_with_solvent_contrib)
label="FMODEL"
if params.sfcalc.parameters.output_type == "intensities":
result = abs(calc_data_with_solvent_contrib)
result = result.f_as_f_sq()
label="IMODEL"
#write an mtz file with the data
mtz_dataset = result.as_mtz_dataset(
column_root_label=label)
mtz_dataset.mtz_object().write(
file_name=params.sfcalc.output.hklout)
#write the logfile
logger = open( params.sfcalc.output.logfile, 'w')
print >> log, "writing log file with name %s"%(params.sfcalc.output.logfile)
print >> log
print >> logger, string_buffer.getvalue()
def run(args, command_name="phenix.xmanip"):
if (len(args) == 0 or "--help" in args or "--h" in args or "-h" in args):
print_help(command_name=command_name)
else:
log = multi_out()
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="map_coefs")
print("#phil __OFF__", file=log)
print("==========================", file=log)
print(" XMANIP ", file=log)
print("reindexing and other tasks", file=log)
print("==========================", file=log)
print(file=log)
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
if not arg_is_processed:
print("##----------------------------------------------##",
file=log)
print("## Unknown file or keyword:", arg, file=log)
print("##----------------------------------------------##",
file=log)
print(file=log)
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params = effective_params.extract()
# now get the unit cell from the files
hkl_xs = []
pdb_xs = None
#multiple file names are allowed
for xray_data in params.xmanip.input.xray_data:
if xray_data.file_name is not None:
hkl_xs.append(
crystal_symmetry_from_any.extract_from(
file_name=xray_data.file_name))
if params.xmanip.input.model.file_name is not None:
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.xmanip.input.model.file_name)
phil_xs = crystal.symmetry(
unit_cell=params.xmanip.input.unit_cell,
space_group_info=params.xmanip.input.space_group)
combined_xs = crystal.select_crystal_symmetry(None, phil_xs, [pdb_xs],
hkl_xs)
if combined_xs is not None:
# inject the unit cell and symmetry in the phil scope please
params.xmanip.input.unit_cell = combined_xs.unit_cell()
params.xmanip.input.space_group = \
sgtbx.space_group_info( group = combined_xs.space_group() )
print("#phil __ON__", file=log)
new_params = master_params.format(python_object=params)
new_params.show(out=log)
print("#phil __END__", file=log)
if params.xmanip.input.unit_cell is None:
raise Sorry("unit cell not specified")
if params.xmanip.input.space_group is None:
raise Sorry("space group not specified")
#-----------------------------------------------------------
#
# step 1: read in the reflection file
#
miller_arrays = []
labels = []
label_appendix = []
write_it = []
names = {}
if len(params.xmanip.input.xray_data) > 0:
phil_xs = crystal.symmetry(
unit_cell=params.xmanip.input.unit_cell,
space_group_info=params.xmanip.input.space_group)
xray_data_server = reflection_file_utils.reflection_file_server(
crystal_symmetry=phil_xs,
force_symmetry=True,
reflection_files=[])
count = 0
for xray_data in params.xmanip.input.xray_data:
if xray_data.file_name is not None:
miller_array = None
miller_array = read_data(xray_data.file_name,
xray_data.labels, phil_xs)
print(file=log)
print("Summary info of observed data", file=log)
print("=============================", file=log)
if miller_array is None:
raise Sorry("Failed to read data. see errors above")
miller_array.show_summary(f=log)
print(file=log)
miller_arrays.append(miller_array)
labels.append(miller_array.info().labels)
label_appendix.append(xray_data.label_appendix)
this_name = "COL_" + str(count)
if xray_data.name is not None:
this_name = xray_data.name
#check if this name is allready used
if this_name in names:
raise Sorry(
"Non unique dataset name. Please change the input script"
)
names.update({this_name: count})
count += 1
write_it.append(xray_data.write_out)
output_label_root = construct_output_labels(labels, label_appendix)
for ii in range(len(labels)):
test = 0
for jj in range(ii + 1, len(labels)):
for lab_name1, lab_name2 in zip(labels[ii], labels[jj]):
if lab_name1 == lab_name2:
test += 1
if test == 2:
print(
"\n***** You are trying to import the data with label(s) %s more then one time. ***** \n"
% (str(labels[ii])),
file=log)
for ii in range(len(output_label_root)):
for jj in range(ii + 1, len(output_label_root)):
if output_label_root[ii] == output_label_root[jj]:
if write_it[ii]:
if write_it[jj]:
print("Output label roots:", file=log)
print(output_label_root, file=log)
raise Sorry(
"Output labels are not unique. Modify input."
)
#----------------------------------------------------------------
# Step 2: get an xray structure from the PDB file
#
pdb_model = None
model = None
if params.xmanip.input.model.file_name is not None:
pdb_model = iotbx.pdb.input(
file_name=params.xmanip.input.model.file_name)
model = pdb_model.xray_structure_simple(crystal_symmetry=phil_xs)
print("Atomic model summary", file=log)
print("====================", file=log)
model.show_summary(f=log)
print(file=log)
write_miller_array = False
write_pdb_file = False
# define some output holder thingamebobs
new_miller_arrays = []
new_model = None
#manipulate miller arrays
if params.xmanip.parameters.action == "manipulate_miller":
write_miller_array = True
new_miller = xmanip_tasks.manipulate_miller(
names, miller_arrays, model,
params.xmanip.parameters.manipulate_miller, log)
miller_arrays.append(new_miller)
# not very smart to rely here on a phil defintion defined in another file
tmp_root = params.xmanip.parameters.manipulate_miller.output_label_root
if tmp_root is None:
tmp_root = "UNSPECIFIED"
output_label_root.append(tmp_root)
write_it.append(True)
if params.xmanip.parameters.action == "reindex":
write_miller_array = True
#----------------------------------------------------------------
# step 3: get the reindex laws
phil_xs.show_summary()
to_niggli = phil_xs.change_of_basis_op_to_niggli_cell()
to_reference = phil_xs.change_of_basis_op_to_reference_setting()
to_inverse = phil_xs.change_of_basis_op_to_inverse_hand()
to_primitive = phil_xs.change_of_basis_op_to_primitive_setting()
cb_op = None
if (params.xmanip.parameters.reindex.standard_laws == "niggli"):
cb_op = to_niggli
if (params.xmanip.parameters.reindex.standard_laws ==
"reference_setting"):
cb_op = to_reference
if (params.xmanip.parameters.reindex.standard_laws == "invert"):
cb_op = to_inverse
if (params.xmanip.parameters.reindex.standard_laws ==
"user_supplied"):
cb_op = sgtbx.change_of_basis_op(
params.xmanip.parameters.reindex.user_supplied_law)
if (params.xmanip.parameters.reindex.standard_laws ==
"primitive_setting"):
cb_op = to_primitive
if cb_op is None:
raise Sorry("No change of basis operation is supplied.")
print("Supplied reindexing law:", file=log)
print("========================", file=log)
print("hkl notation: ", cb_op.as_hkl(), file=log)
print("xyz notation: ", cb_op.as_xyz(), file=log)
print("abc notation: ", cb_op.as_abc(), file=log)
#----------------------------------------------------------------
# step 4: do the reindexing
#
# step 4a: first do the miller array object
#new_miller_arrays = []
for miller_array in miller_arrays:
new_miller_array = None
if miller_array is not None:
new_miller_array = miller_array.change_basis(cb_op)
new_miller_arrays.append(new_miller_array)
#
# step 4b: the xray structure
if pdb_model is not None:
write_pdb_file = True
new_model = model.change_basis(cb_op)
if write_miller_array:
if len(new_miller_arrays) == 0:
new_miller_arrays = miller_arrays
#----------------------------------------------------------------
print(file=log)
print("The data has been reindexed/manipulated", file=log)
print("--------------------------------------", file=log)
print(file=log)
print("Writing output files....", file=log)
mtz_dataset = None
if len(new_miller_arrays) > 0:
first = 0
for item in range(len(write_it)):
if write_it[item]:
first = item
if new_miller_arrays[first] is not None:
break
if new_miller_arrays[first] is not None:
tmp = new_miller_arrays[first].map_to_asu()
mtz_dataset = tmp.as_mtz_dataset(
column_root_label=output_label_root[first])
if mtz_dataset is not None:
for miller_array, new_root in zip(
new_miller_arrays[first + 1:],
output_label_root[first + 1:]):
if miller_array is not None:
mtz_dataset = mtz_dataset.add_miller_array(
miller_array=miller_array,
column_root_label=new_root)
print("Writing mtz file with name %s" %
(params.xmanip.output.hklout),
file=log)
mtz_dataset.mtz_object().write(
file_name=params.xmanip.output.hklout)
#step 5b: write the new pdb file
if new_model is not None:
pdb_file = open(params.xmanip.output.xyzout, 'w')
print("Wring pdb file to: %s" % (params.xmanip.output.xyzout),
file=log)
write_as_pdb_file(input_pdb=pdb_model,
input_xray_structure=new_model,
out=pdb_file,
chain_id_increment=0,
additional_remark="Generated by %s" %
command_name)
pdb_file.close()
if ([miller_array, new_model]).count(None) == 2:
print(
"No input reflection of coordinate files have been given",
file=log)
if params.xmanip.parameters.action == "manipulate_pdb":
if params.xmanip.parameters.manipulate_pdb.task == "apply_operator":
rt_mx = None
if params.xmanip.parameters.manipulate_pdb.apply_operator.standard_operators == "user_supplied_operator":
rt_mx = sgtbx.rt_mx(
params.xmanip.parameters.manipulate_pdb.apply_operator.
user_supplied_operator,
t_den=12 * 8)
print("Applied operator : ", rt_mx.as_xyz(), file=log)
if params.xmanip.parameters.manipulate_pdb.apply_operator.standard_operators == \
"user_supplied_cartesian_rotation_matrix":
rt = params.xmanip.parameters.manipulate_pdb.apply_operator.user_supplied_cartesian_rotation_matrix
tmp_r = None
tmp_t = None
if "," in rt.r:
tmp_r = rt.r.split(',')
else:
tmp_r = rt.r.split(' ')
if "," in rt.r:
tmp_t = rt.t.split(',')
else:
tmp_t = rt.t.split(' ')
tmp_tmp_r = []
tmp_tmp_t = []
for item in tmp_r:
tmp_tmp_r.append(float(item))
if len(tmp_tmp_r) != 9:
raise Sorry(
"Invalid rotation matrix. Please check input: %s" %
(rt.r))
for item in tmp_t:
tmp_tmp_t.append(float(item))
if len(tmp_tmp_t) != 3:
raise Sorry(
"Invalid translational vector. Please check input: %s"
% (rt.t))
tmp_tmp_t = (tmp_tmp_t)
rt_mx = quick_rt_mx(tmp_tmp_r, tmp_tmp_t)
print("User supplied cartesian matrix and vector: ",
file=log)
rt_mx.show()
o = matrix.sqr(
model.unit_cell().orthogonalization_matrix())
tmp_r = o.inverse() * rt_mx.r() * o
tmp_t = o.inverse() * matrix.col(list(rt_mx.t()))
print(file=log)
print("Operator in fractional coordinates: ", file=log)
rt_mx = quick_rt_mx(r=tmp_r.as_float(), t=list(tmp_t))
rt_mx.show(out=log)
print(file=log)
if params.xmanip.parameters.manipulate_pdb.apply_operator.invert:
rt_mx = rt_mx.inverse()
print(file=log)
print("Taking inverse of given operator", file=log)
print(file=log)
sites = model.sites_frac()
new_sites = flex.vec3_double()
for site in sites:
new_site = rt_mx.r() * matrix.col(site)
new_site = flex.double(new_site) + flex.double(
rt_mx.t().as_double())
new_sites.append(tuple(new_site))
new_model = model.deep_copy_scatterers()
new_model.set_sites_frac(new_sites)
# write the new [pdb file please
pdb_file = open(params.xmanip.output.xyzout, 'w')
print("Wring pdb file to: %s" % (params.xmanip.output.xyzout),
file=log)
if params.xmanip.parameters.manipulate_pdb.apply_operator.concatenate_model:
write_as_pdb_file(input_pdb=pdb_model,
input_xray_structure=model,
out=pdb_file,
chain_id_increment=0,
additional_remark=None,
print_cryst_and_scale=True)
write_as_pdb_file(
input_pdb=pdb_model,
input_xray_structure=new_model,
out=pdb_file,
chain_id_increment=params.xmanip.parameters.manipulate_pdb.
apply_operator.chain_id_increment,
additional_remark=None,
print_cryst_and_scale=False)
pdb_file.close()
if params.xmanip.parameters.manipulate_pdb.task == "set_b":
#rest all the b values
if params.xmanip.parameters.manipulate_pdb.set_b:
b_iso = params.xmanip.parameters.manipulate_pdb.b_iso
new_model = model.set_b_iso(value=b_iso)
print(file=log)
print("All B-values have been set to %5.3f" % (b_iso),
file=log)
print("Writing PDB file %s" %
(params.xmanip.output.xyzout),
file=log)
print(file=log)
pdb_file = open(params.xmanip.output.xyzout, 'w')
write_as_pdb_file(input_pdb=pdb_model,
input_xray_structure=new_model,
out=pdb_file,
chain_id_increment=0,
additional_remark=None,
print_cryst_and_scale=True)
pdb_file.close()
#write the logfile
logger = open(params.xmanip.output.logfile, 'w')
print("Writing log file with name %s " %
(params.xmanip.output.logfile),
file=log)
print(string_buffer.getvalue()[0:len(string_buffer.getvalue()) - 1],
file=logger) #avoid a newline at the end ...
logger.close()
def run(args, command_name="phenix.twin_map_utils"):
log=sys.stdout
params=None
if (len(args) == 0 or "--help" in args or "--h" in args or "-h" in args):
print_help(command_name=command_name)
else:
log = multi_out()
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="map_coefs")
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
if not arg_is_processed:
print >> log, "##----------------------------------------------##"
print >> log, "## Unknown file or keyword:", arg
print >> log, "##----------------------------------------------##"
print >> log
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params = effective_params.extract()
"""
new_params = master_params.format(python_object=params)
new_params.show(out=log)
"""
# now get the unit cell from the pdb file
hkl_xs = crystal_symmetry_from_any.extract_from(
file_name=params.twin_utils.input.xray_data.file_name)
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.twin_utils.input.model.file_name)
phil_xs=None
if ([params.twin_utils.input.unit_cell,
params.twin_utils.input.space_group]).count(None)<2:
phil_xs = crystal.symmetry(
unit_cell=params.twin_utils.input.unit_cell,
space_group_info=params.twin_utils.input.space_group )
combined_xs = crystal.select_crystal_symmetry(
None,phil_xs, [pdb_xs],[hkl_xs])
# inject the unit cell and symmetry in the phil scope please
params.twin_utils.input.unit_cell = combined_xs.unit_cell()
params.twin_utils.input.space_group = \
sgtbx.space_group_info( group = combined_xs.space_group() )
new_params = master_params.format(python_object=params)
new_params.show(out=log)
if params.twin_utils.input.unit_cell is None:
raise Sorry("unit cell not specified")
if params.twin_utils.input.space_group is None:
raise Sorry("space group not specified")
if params.twin_utils.input.xray_data.file_name is None:
raise Sorry("Xray data not specified")
if params.twin_utils.input.model.file_name is None:
raise Sorry("pdb file with model not specified")
#-----------------------------------------------------------
#
# step 1: read in the reflection file
#
phil_xs = crystal.symmetry(
unit_cell=params.twin_utils.input.unit_cell,
space_group_info=params.twin_utils.input.space_group )
xray_data_server = reflection_file_utils.reflection_file_server(
crystal_symmetry = phil_xs,
force_symmetry = True,
reflection_files=[])
miller_array = None
free_flags = None
tmp_params = utils.data_and_flags_master_params().extract()
# insert proper values please
tmp_params.file_name = params.twin_utils.input.xray_data.file_name
tmp_params.labels = params.twin_utils.input.xray_data.obs_labels
tmp_params.r_free_flags.file_name=params.twin_utils.input.xray_data.file_name
tmp_params.r_free_flags.label=params.twin_utils.input.xray_data.free_flag
tmp_object = utils.determine_data_and_flags( reflection_file_server = xray_data_server,
parameters = tmp_params, log=log )
miller_array = tmp_object.extract_data()
if miller_array.is_xray_intensity_array():
miller_array = miller_array.f_sq_as_f()
assert miller_array.is_xray_amplitude_array()
free_flags = tmp_object.extract_flags(data = miller_array)
print >> log
print >> log, "Attempting to extract Free R flags"
free_flags = free_flags.customized_copy( data = flex.bool( free_flags.data()==1 ) )
if free_flags is None:
free_flags = miller_array.generate_r_free_flags(use_lattice_symmetry=True)
assert miller_array.observation_type() is not None
print >> log
print >> log, "Summary info of observed data"
print >> log, "============================="
miller_array.show_summary(f=log)
print >> log
if miller_array.indices().size() == 0:
raise Sorry("No data available")
#----------------------------------------------------------------
# Step 2: get an xray structure from the PDB file
#
model = pdb.input(file_name=params.twin_utils.input.model.file_name).xray_structure_simple(
crystal_symmetry=phil_xs)
print >> log, "Atomic model summary"
print >> log, "===================="
model.show_summary(f=log)
print >> log
#----------------------------------------------------------------
# step 3: get the twin laws for this xs
twin_laws = twin_analyses.twin_laws(
miller_array,
lattice_symmetry_max_delta=\
params.twin_utils.parameters.twinning.max_delta,
out=log)
print >> log
print >> log, "Preliminary data analyses"
print >> log, "=========================="
twin_laws.show(out=log)
#---------
# step 3:
# make twin model managers for all twin laws
print >> log
print >> log, "Overall and bulk solvent scale paranmeters and twin fraction estimation"
print >> log, "======================================================================="
twin_models = []
operator_count = 0
if params.twin_utils.parameters.twinning.twin_law is not None:
tmp_law = sgtbx.rt_mx( params.twin_utils.parameters.twinning.twin_law )
tmp_law = twin_analyses.twin_law(tmp_law,None,None,None,None,None)
twin_laws.operators = [ tmp_law ]
for twin_law in twin_laws.operators:
operator_count += 1
operator_hkl = sgtbx.change_of_basis_op( twin_law.operator ).as_hkl()
twin_model = twin_f_model.twin_model_manager(
f_obs=miller_array,
r_free_flags = free_flags,
xray_structure=model,
twin_law = twin_law.operator,
detwin_mode = params.twin_utils.parameters.twinning.detwin_mode,
out=log)
print >> log, "--- bulk solvent scaling ---"
twin_model.update_solvent_and_scale(update_f_part1=False)
twin_model.r_values()
twin_model.target()
twin_model.show_k_sol_b_sol_b_cart_target()
twin_model.show_essential()
wfofc = twin_model.map_coefficients(map_type="mFo-DFc" )
wtfofc = twin_model.map_coefficients(map_type="2mFo-DFc" )
grad = twin_model.map_coefficients(map_type="gradient" )
mtz_dataset = wtfofc.as_mtz_dataset(
column_root_label="FWT")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array = wfofc,
column_root_label = "DFWT"
)
mtz_dataset = mtz_dataset.add_miller_array(
miller_array = grad,
column_root_label = "GRAD"
)
name = params.twin_utils.output.map_coeffs_root+"_"+str(operator_count)+".mtz"
print >> log
print >> log, "Writing %s for twin law %s"%(name,operator_hkl)
print >> log
mtz_dataset.mtz_object().write(
file_name=name)
if params.twin_utils.output.obs_and_calc is not None:
# i want also a Fobs and Fmodel combined dataset please
mtz_dataset = miller_array.as_mtz_dataset(
column_root_label="FOBS")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array = twin_model.f_model(),
column_root_label="FMODEL")
name = params.twin_utils.output.obs_and_calc
mtz_dataset.mtz_object().write(
file_name=name)
if len(twin_laws.operators)==0:
print >> log
print >> log, "No twin laws were found"
print >> log, "Performing maximum likelihood based bulk solvent scaling"
f_model_object = f_model.manager(
f_obs = miller_array,
r_free_flags = free_flags,
xray_structure = model )
f_model_object.update_solvent_and_scale(out=log)
tfofc = f_model_object.map_coefficients(map_type="2mFobs-DFmodel")
fofc = f_model_object.map_coefficients(map_type="mFobs-DFmodel")
mtz_dataset = tfofc.as_mtz_dataset(
column_root_label="FWT")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array = fofc,
column_root_label = "DELFWT"
)
name = params.twin_utils.output.map_coeffs_root+"_ML.mtz"
mtz_dataset.mtz_object().write(
file_name=name)
if params.twin_utils.output.obs_and_calc is not None:
# i want also a Fobs and Fmodel combined dataset please
mtz_dataset = miller_array.as_mtz_dataset(
column_root_label="FOBS")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array = f_model_object.f_model(),
column_root_label="FMODEL")
name = params.twin_utils.output.obs_and_calc
mtz_dataset.mtz_object().write(
file_name=name)
print >> log
print >> log
print >> log, "All done \n"
logfile = open(params.twin_utils.output.logfile,'w')
print >> logfile, string_buffer.getvalue()
print >> log
def run(args,
log=sys.stdout,
use_output_directory=True,
suppress_fmodel_output=False):
print >> log, legend
print >> log, "-" * 79
master_params = mmtbx.maps.maps_including_IO_master_params()
if (len(args) == 0 or (len(args) == 1 and args[0] == "NO_PARAMETER_FILE")):
if (not (len(args) == 1 and args[0] == "NO_PARAMETER_FILE")):
parameter_file_name = "maps.params"
print >> log, "Creating parameter file '%s' in the following directory:\n%s" % (
parameter_file_name, os.path.abspath('.'))
if (os.path.isfile(parameter_file_name)):
msg = "File '%s' exists already. Re-name it or move and run the command again."
raise Sorry(msg % parameter_file_name)
pfo = open(parameter_file_name, "w")
else:
pfo = log
print >> pfo, "\nAll phenix.maps parameters::\n"
master_params = master_params.fetch(iotbx.phil.parse(default_params))
master_params.show(out=pfo, prefix=" ", expert_level=1)
return
processed_args = mmtbx.utils.process_command_line_args(
args=args, log=log, master_params=master_params)
working_phil = processed_args.params
params = working_phil.extract()
fmodel_data_file_format = params.maps.output.fmodel_data_file_format
if (len(params.maps.map_coefficients) == 0) and (len(params.maps.map)
== 0):
print >> log, "No map input specified - using default map types"
working_phil = master_params.fetch(
sources=[working_phil,
iotbx.phil.parse(default_params)])
params = working_phil.extract()
# XXX BUG - the extra fetch will always set fmodel_data_file_format to
# mtz; this is probaby a low-level phil problem
if (fmodel_data_file_format is None) or (suppress_fmodel_output):
params.maps.output.fmodel_data_file_format = None
analyze_input_params(params=params)
have_phil_file_input = len(processed_args.phil_file_names) > 0
if (len(processed_args.pdb_file_names) > 1):
raise Sorry("Only one model file is allowed as input.")
if ((params.maps.input.pdb_file_name is None)
and (len(processed_args.pdb_file_names) == 1)):
params.maps.input.pdb_file_name = processed_args.pdb_file_names[0]
if (not os.path.isfile(str(params.maps.input.pdb_file_name))):
raise Sorry(
"model file is not given: maps.input.pdb_file_name=%s is not a file"%\
str(params.maps.input.pdb_file_name))
if ((params.maps.input.reflection_data.file_name is None) and
(params.maps.input.reflection_data.r_free_flags.file_name is None)
and (len(processed_args.reflection_file_names) == 1)):
params.maps.input.reflection_data.file_name = \
processed_args.reflection_file_names[0]
print >> log, "FORMAT:", params.maps.output.fmodel_data_file_format
working_phil = master_params.format(python_object=params)
print >> log, "-" * 79
print >> log, "\nParameters to compute maps::\n"
working_phil.show(out=log, prefix=" ")
pdb_inp = iotbx.pdb.input(file_name=params.maps.input.pdb_file_name)
# get all crystal symmetries
cs_from_coordinate_files = [pdb_inp.crystal_symmetry_from_cryst1()]
cs_from_reflection_files = []
for rfn in [
params.maps.input.reflection_data.file_name,
params.maps.input.reflection_data.r_free_flags.file_name
]:
if (os.path.isfile(str(rfn))):
try:
cs_from_reflection_files.append(
crystal_symmetry_from_any.extract_from(rfn))
except KeyboardInterrupt:
raise
except RuntimeError:
pass
crystal_symmetry = None
try:
crystal_symmetry = crystal.select_crystal_symmetry(
from_coordinate_files=cs_from_coordinate_files,
from_reflection_files=cs_from_reflection_files)
except AssertionError, e:
if ("No unit cell and symmetry information supplied" in str(e)):
raise Sorry(
"Missing or incomplete symmetry information. This program " +
"will only work with reflection file formats that contain both "
+ "unit cell and space group records, such as MTZ files.")
def reindex_utils(args):
if len(args) == 0:
print_help()
elif ("--help" in args):
print_help()
elif ("--h" in args):
print_help()
elif ("-h" in args):
print_help()
else:
log = multi_out()
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="map_coefs")
print >> log, "#phil __OFF__"
print >> log, "================="
print >> log, " REINDEX "
print >> log, "A reindexing tool"
print >> log, "================="
print >> log
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
if not arg_is_processed:
print >> log, "##----------------------------------------------##"
print >> log, "## Unknown file or keyword:", arg
print >> log, "##----------------------------------------------##"
print >> log
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params_root = effective_params.extract()
params = params_root.reindex_utils
# now get the unit cell from the files
hkl_xs = None
pdb_xs = None
if params.input.xray_data.file_name is not None:
hkl_xs = crystal_symmetry_from_any.extract_from(
file_name=params.input.xray_data.file_name)
if params.input.model.file_name is not None:
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.input.model.file_name)
phil_xs = crystal.symmetry(unit_cell=params.input.unit_cell,
space_group_info=params.input.space_group)
combined_xs = crystal.select_crystal_symmetry(None, phil_xs, [pdb_xs],
[hkl_xs])
# inject the unit cell and symmetry in the phil scope please
params.input.unit_cell = combined_xs.unit_cell()
params.input.space_group = combined_xs.space_group_info()
print >> log, "#phil __ON__"
new_params = master_params.format(python_object=params_root)
new_params.show(out=log)
print >> log, "#phil __END__"
if params.input.unit_cell is None:
raise Sorry("unit cell not specified")
if params.input.space_group is None:
raise Sorry("space group not specified")
#-----------------------------------------------------------
#
# step 1: read in the reflection file
#
miller_array = None
if params.input.xray_data.file_name is not None:
phil_xs = crystal.symmetry(
unit_cell=params.input.unit_cell,
space_group_info=params.input.space_group)
xray_data_server = reflection_file_utils.reflection_file_server(
crystal_symmetry=phil_xs,
force_symmetry=True,
reflection_files=[])
miller_array = xray_data_server.get_xray_data(
file_name=params.input.xray_data.file_name,
labels=params.input.xray_data.labels,
ignore_all_zeros=True,
parameter_scope='reindex_utils.input.xray_data',
parameter_name='labels')
info = miller_array.info()
miller_array = miller_array.map_to_asu()
miller_array = miller_array.select(
miller_array.indices() != (0, 0, 0))
miller_array = miller_array.select(miller_array.data() > 0)
if miller_array.sigmas() is not None:
miller_array = miller_array.select(miller_array.sigmas() > 0)
if (miller_array.is_xray_intensity_array()):
miller_array = miller_array.f_sq_as_f()
elif (miller_array.is_complex_array()):
miller_array = abs(miller_array)
miller_array.set_info(info)
print >> log
print >> log, "Summary info of observed data"
print >> log, "============================="
miller_array.show_summary(f=log)
print >> log
#----------------------------------------------------------------
# Step 2: get an xray structure from the PDB file
#
pdb_model = None
if params.input.model.file_name is not None:
pdb_model = iotbx.pdb.input(file_name=params.input.model.file_name)
model = pdb_model.xray_structure_simple(crystal_symmetry=phil_xs)
print >> log, "Atomic model summary"
print >> log, "===================="
model.show_summary()
print >> log
if params.parameters.action == "reindex":
#----------------------------------------------------------------
# step 3: get the reindex laws
to_niggli = phil_xs.change_of_basis_op_to_niggli_cell()
to_reference = phil_xs.change_of_basis_op_to_reference_setting()
to_inverse = phil_xs.change_of_basis_op_to_inverse_hand()
cb_op = None
pr = params.parameters.reindex
if (pr.standard_laws == "niggli"):
cb_op = to_niggli
elif (pr.standard_laws == "reference_setting"):
cb_op = to_reference
elif (pr.standard_laws == "invert"):
cb_op = to_inverse
else:
cb_op = sgtbx.change_of_basis_op(pr.user_supplied_law)
if cb_op is None:
raise Sorry("No change of basis operation is supplied.")
if params.parameters.inverse:
cb_op = cb_op.inverse()
print >> log, "Supplied reindexing law:"
print >> log, "========================"
print >> log, "hkl notation: ", cb_op.as_hkl()
print >> log, "xyz notation: ", cb_op.as_xyz()
print >> log, "abc notation: ", cb_op.as_abc()
#----------------------------------------------------------------
# step 4: do the reindexing
#
# step 4a: first do the miller array object
new_miller_array = None
if miller_array is not None:
new_miller_array = miller_array.change_basis(cb_op)
#
# step 4b: the xray structure
new_model = None
if pdb_model is not None:
new_model = model.change_basis(cb_op)
#----------------------------------------------------------------
# step 5a: write the new mtz file
print >> log
print >> log, "The data and model have been reindexed"
print >> log, "--------------------------------------"
print >> log
print >> log, "Writing output files...."
if miller_array is not None:
print >> log, "writing mtz file with name %s" % (
params.output.hklout)
mtz_dataset = new_miller_array.as_mtz_dataset(
column_root_label="FOBS")
mtz_dataset.mtz_object().write(file_name=params.output.hklout)
#step 5b: write the new pdb file
if new_model is not None:
pdb_file = open(params.output.xyzout, 'w')
print >> log, "Wring pdb file to: %s" % params.output.xyzout
write_as_pdb_file(
input_pdb=pdb_model,
input_xray_structure=new_model,
out=pdb_file,
chain_id_increment=params.parameters.chain_id_increment,
additional_remark="Generated by mmtbx reindex")
print >> pdb_file, "END"
pdb_file.close()
if ([miller_array, new_model]).count(None) == 2:
print >> log, "No input reflection of coordinate files have been given"
if params.parameters.action == "operator":
rt_mx = sgtbx.rt_mx(
params.parameters.apply_operator.user_supplied_operator,
t_den=12 * 8)
if params.parameters.inverse:
rt_mx = rt_mx.inverse()
print >> log
print >> log, "Applied operator : ", rt_mx.as_xyz()
print >> log
sites = model.sites_frac()
new_sites = flex.vec3_double()
for site in sites:
new_site = rt_mx.r() * matrix.col(site)
new_site = flex.double(new_site) + flex.double(
rt_mx.t().as_double())
new_sites.append(tuple(new_site))
new_model = model.deep_copy_scatterers()
new_model.set_sites_frac(new_sites)
# write the new [pdb file please
pdb_file = open(params.output.xyzout, 'w')
print >> log, "Wring pdb file to: %s" % params.output.xyzout
if params.parameters.apply_operator.concatenate_model:
write_as_pdb_file(input_pdb=pdb_model,
input_xray_structure=model,
out=pdb_file,
chain_id_increment=0,
additional_remark=None,
print_cryst_and_scale=True)
write_as_pdb_file(
input_pdb=pdb_model,
input_xray_structure=new_model,
out=pdb_file,
chain_id_increment=params.parameters.chain_id_increment,
additional_remark=None,
print_cryst_and_scale=False)
print >> pdb_file, "END"
pdb_file.close()
if params.parameters.action == "manipulate_pdb":
#rest all the b values
if params.parameters.manipulate_pdb.set_b:
b_iso = params.reindex_utils.parameters.manipulate_pdb.b_iso
new_model = model.set_b_iso(value=b_iso)
print >> log
print >> log, "All B-values have been set to %5.3f" % (b_iso)
print >> log, "Writing PDB file %s" % (params.output.xyzout)
print >> log
pdb_file = open(params.output.xyzout, 'w')
write_as_pdb_file(input_pdb=pdb_model,
input_xray_structure=new_model,
out=pdb_file,
chain_id_increment=0,
additional_remark=None,
print_cryst_and_scale=True)
print >> pdb_file, "END"
pdb_file.close()
#write the logfile
logger = open(params.output.logfile, 'w')
print >> log, "Writing log file with name %s" % params.output.logfile
print >> log
print >> logger, string_buffer.getvalue()
def run(args):
# processing command-line stuff, out of the object
log = multi_out()
log.register("stdout", sys.stdout)
if len(args) == 0:
format_usage_message(log)
return
input_objects = process_command_line_with_files(
args=args,
master_phil=master_params(),
pdb_file_def="model_file_name",
map_file_def="map_file_name",
reflection_file_def="hkl_file_name",
cif_file_def="ligands_file_name")
work_params = input_objects.work.extract()
if [work_params.map_file_name, work_params.hkl_file_name].count(None) < 1:
raise Sorry("Only one source of map could be supplied.")
input_objects.work.show(prefix=" ", out=log)
if len(work_params.model_file_name) == 0:
raise Sorry("No PDB file specified")
if work_params.output_prefix is None:
work_params.output_prefix = os.path.basename(
work_params.model_file_name[0])
log_file_name = "%s.log" % work_params.output_prefix
logfile = open(log_file_name, "w")
log.register("logfile", logfile)
err_log = multi_out()
err_log.register(label="log", file_object=log)
# err_log.register(label="stderr", file_object=sys.stderr)
sys.stderr = err_log
if work_params.loop_idealization.output_prefix is None:
work_params.loop_idealization.output_prefix = "%s_rama_fixed" % work_params.output_prefix
# Here we start opening files provided,
# collect crystal symmetries
pdb_combined = iotbx.pdb.combine_unique_pdb_files(
file_names=work_params.model_file_name)
pdb_input = iotbx.pdb.input(source_info=None,
lines=flex.std_string(
pdb_combined.raw_records))
pdb_cs = pdb_input.crystal_symmetry()
crystal_symmetry = None
map_cs = None
map_content = input_objects.get_file(work_params.map_file_name)
if map_content is not None:
try:
map_cs = map_content.crystal_symmetry()
except NotImplementedError as e:
pass
try:
crystal_symmetry = crystal.select_crystal_symmetry(
from_command_line=None,
from_parameter_file=None,
from_coordinate_files=[pdb_cs],
from_reflection_files=[map_cs],
enforce_similarity=True)
except AssertionError as e:
if len(e.args) > 0 and e.args[0].startswith(
"No unit cell and symmetry information supplied"):
pass
else:
raise e
model = mmtbx.model.manager(model_input=pdb_input,
restraint_objects=input_objects.cif_objects,
crystal_symmetry=crystal_symmetry,
process_input=False,
log=log)
map_data = None
shift_manager = None
if map_content is not None:
map_data, map_cs, shift_manager = get_map_from_map(
map_content, work_params, xrs=model.get_xray_structure(), log=log)
model.shift_model_and_set_crystal_symmetry(
shift_cart=shift_manager.shift_cart)
# model.get_hierarchy().write_pdb_file("junk_shift.pdb")
hkl_content = input_objects.get_file(work_params.hkl_file_name)
if hkl_content is not None:
map_data, map_cs = get_map_from_hkl(
hkl_content,
work_params,
xrs=model.get_xray_structure(
), # here we don't care about atom order
log=log)
mi_object = model_idealization(model=model,
map_data=map_data,
params=work_params,
log=log,
verbose=False)
mi_object.run()
mi_object.print_stat_comparison()
print("RMSD from starting model (backbone, all): %.4f, %.4f" %
(mi_object.get_rmsd_from_start(), mi_object.get_rmsd_from_start2()),
file=log)
mi_object.print_runtime()
# add hydrogens if needed ?
print("All done.", file=log)
log.flush()
sys.stderr = sys.__stderr__
log.close()
def run(args, command_name="phenix.remove_outliers"):
if (len(args) == 0 or "--help" in args or "--h" in args or "-h" in args):
print_help(command_name=command_name)
else:
log = multi_out()
plot_out = None
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="outlier_detection")
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if arg == "--quiet":
arg_is_processed = True
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt:
raise
except Exception:
pass
if not arg_is_processed:
print >> log, "##----------------------------------------------##"
print >> log, "## Unknown file or keyword:", arg
print >> log, "##----------------------------------------------##"
print >> log
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params = effective_params.extract()
if not os.path.exists(params.outlier_utils.input.xray_data.file_name):
raise Sorry("File %s can not be found" %
(params.outlier_utils.input.xray_data.file_name))
if params.outlier_utils.input.model.file_name is not None:
if not os.path.exists(params.outlier_utils.input.model.file_name):
raise Sorry("File %s can not be found" %
(params.outlier_utils.input.model.file_name))
# now get the unit cell from the pdb file
hkl_xs = None
if params.outlier_utils.input.xray_data.file_name is not None:
hkl_xs = crystal_symmetry_from_any.extract_from(
file_name=params.outlier_utils.input.xray_data.file_name)
pdb_xs = None
if params.outlier_utils.input.model.file_name is not None:
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.outlier_utils.input.model.file_name)
phil_xs = crystal.symmetry(
unit_cell=params.outlier_utils.input.unit_cell,
space_group_info=params.outlier_utils.input.space_group)
phil_xs.show_summary()
hkl_xs.show_summary()
combined_xs = crystal.select_crystal_symmetry(None, phil_xs, [pdb_xs],
[hkl_xs])
# inject the unit cell and symmetry in the phil scope please
params.outlier_utils.input.unit_cell = combined_xs.unit_cell()
params.outlier_utils.input.space_group = \
sgtbx.space_group_info( group = combined_xs.space_group() )
new_params = master_params.format(python_object=params)
new_params.show(out=log)
if params.outlier_utils.input.unit_cell is None:
raise Sorry("unit cell not specified")
if params.outlier_utils.input.space_group is None:
raise Sorry("space group not specified")
if params.outlier_utils.input.xray_data.file_name is None:
raise Sorry("Xray data not specified")
if params.outlier_utils.input.model.file_name is None:
print "PDB file not specified. Basic wilson outlier rejections only."
#-----------------------------------------------------------
#
# step 1: read in the reflection file
#
phil_xs = crystal.symmetry(
unit_cell=params.outlier_utils.input.unit_cell,
space_group_info=params.outlier_utils.input.space_group)
xray_data_server = reflection_file_utils.reflection_file_server(
crystal_symmetry=phil_xs, force_symmetry=True, reflection_files=[])
miller_array = None
miller_array = xray_data_server.get_xray_data(
file_name=params.outlier_utils.input.xray_data.file_name,
labels=params.outlier_utils.input.xray_data.obs_labels,
ignore_all_zeros=True,
parameter_scope='outlier_utils.input.xray_data',
parameter_name='obs_labels')
info = miller_array.info()
miller_array = miller_array.map_to_asu()
miller_array = miller_array.select(miller_array.indices() != (0, 0, 0))
#we have to check if the sigma's make any sense at all
if not miller_array.sigmas_are_sensible():
miller_array = miller_array.customized_copy(
data=miller_array.data(),
sigmas=None).set_observation_type(miller_array)
miller_array = miller_array.select(miller_array.data() > 0)
if miller_array.sigmas() is not None:
miller_array = miller_array.select(miller_array.sigmas() > 0)
if (miller_array.is_xray_intensity_array()):
miller_array = miller_array.f_sq_as_f()
elif (miller_array.is_complex_array()):
miller_array = abs(miller_array)
miller_array.set_info(info)
merged_anomalous = False
if miller_array.anomalous_flag():
miller_array = miller_array.average_bijvoet_mates(
).set_observation_type(miller_array)
merged_anomalous = True
miller_array = miller_array.map_to_asu()
# get the free reflections please
free_flags = None
if params.outlier_utils.input.xray_data.free_flags is None:
free_flags = miller_array.generate_r_free_flags(
fraction=params.outlier_utils.\
additional_parameters.free_flag_generation.fraction,
max_free=params.outlier_utils.\
additional_parameters.free_flag_generation.max_number,
lattice_symmetry_max_delta=params.outlier_utils.\
additional_parameters.free_flag_generation.lattice_symmetry_max_delta,
use_lattice_symmetry=params.outlier_utils.\
additional_parameters.free_flag_generation.use_lattice_symmetry
)
else:
free_flags = xray_data_server.get_xray_data(
file_name=params.outlier_utils.input.xray_data.file_name,
labels=params.outlier_utils.input.xray_data.free_flags,
ignore_all_zeros=True,
parameter_scope='outlier_utils.input.xray_data',
parameter_name='free_flags')
if free_flags.anomalous_flag():
free_flags = free_flags.average_bijvoet_mates()
merged_anomalous = True
free_flags = free_flags.customized_copy(data=flex.bool(
free_flags.data() == 1))
free_flags = free_flags.map_to_asu()
free_flags = free_flags.common_set(miller_array)
print >> log
print >> log, "Summary info of observed data"
print >> log, "============================="
miller_array.show_summary(f=log)
if merged_anomalous:
print >> log, "For outlier detection purposes, the Bijvoet pairs have been merged."
print >> log
print >> log, "Constructing an outlier manager"
print >> log, "==============================="
print >> log
outlier_manager = outlier_rejection.outlier_manager(miller_array,
free_flags,
out=log)
basic_array = None
extreme_array = None
model_based_array = None
basic_array = outlier_manager.basic_wilson_outliers(
p_basic_wilson = params.outlier_utils.outlier_detection.\
parameters.basic_wilson.level,
return_data = True)
extreme_array = outlier_manager.extreme_wilson_outliers(
p_extreme_wilson = params.outlier_utils.outlier_detection.parameters.\
extreme_wilson.level,
return_data = True)
beamstop_array = outlier_manager.beamstop_shadow_outliers(
level = params.outlier_utils.outlier_detection.parameters.\
beamstop.level,
d_min = params.outlier_utils.outlier_detection.parameters.\
beamstop.d_min,
return_data=True)
#----------------------------------------------------------------
# Step 2: get an xray structure from the PDB file
#
if params.outlier_utils.input.model.file_name is not None:
model = pdb.input(file_name=params.outlier_utils.input.model.
file_name).xray_structure_simple(
crystal_symmetry=phil_xs)
print >> log, "Atomic model summary"
print >> log, "===================="
model.show_summary(f=log)
print >> log
# please make an f_model object for bulk solvent scaling etc etc
f_model_object = f_model.manager(f_obs=miller_array,
r_free_flags=free_flags,
xray_structure=model)
print >> log, "Bulk solvent scaling of the data"
print >> log, "================================"
print >> log, "Maximum likelihood bulk solvent scaling."
print >> log
f_model_object.update_all_scales(log=log, remove_outliers=False)
plot_out = StringIO()
model_based_array = outlier_manager.model_based_outliers(
f_model_object.f_model(),
level=params.outlier_utils.outlier_detection.parameters.
model_based.level,
return_data=True,
plot_out=plot_out)
#check what needs to be put out please
if params.outlier_utils.output.hklout is not None:
if params.outlier_utils.outlier_detection.protocol == "model":
if params.outlier_utils.input.model.file_name == None:
print >> log, "Model based rejections requested. No model was supplied."
print >> log, "Switching to writing out rejections based on extreme value Wilson statistics."
params.outlier_utils.outlier_detection.protocol = "extreme"
output_array = None
print >> log
if params.outlier_utils.outlier_detection.protocol == "basic":
print >> log, "Non-outliers found by the basic wilson statistics"
print >> log, "protocol will be written out."
output_array = basic_array
new_set_of_free_flags = free_flags.common_set(basic_array)
if params.outlier_utils.outlier_detection.protocol == "extreme":
print >> log, "Non-outliers found by the extreme value wilson statistics"
print >> log, "protocol will be written out."
output_array = extreme_array
new_set_of_free_flags = free_flags.common_set(extreme_array)
if params.outlier_utils.outlier_detection.protocol == "model":
print >> log, "Non-outliers found by the model based"
print >> log, "protocol will be written out to the file:"
print >> log, params.outlier_utils.output.hklout
print >> log
output_array = model_based_array
new_set_of_free_flags = free_flags.common_set(
model_based_array)
if params.outlier_utils.outlier_detection.protocol == "beamstop":
print >> log, "Outliers found for the beamstop shadow"
print >> log, "problems detection protocol will be written to the file:"
print >> log, params.outlier_utils.output.hklout
print >> log
output_array = model_based_array
new_set_of_free_flags = free_flags.common_set(
model_based_array)
mtz_dataset = output_array.as_mtz_dataset(column_root_label="FOBS")
mtz_dataset = mtz_dataset.add_miller_array(
miller_array=new_set_of_free_flags,
column_root_label="Free_R_Flag")
mtz_dataset.mtz_object().write(
file_name=params.outlier_utils.output.hklout)
if (params.outlier_utils.output.logfile is not None):
final_log = StringIO()
print >> final_log, string_buffer.getvalue()
print >> final_log
if plot_out is not None:
print >> final_log, plot_out.getvalue()
outfile = open(params.outlier_utils.output.logfile, 'w')
outfile.write(final_log.getvalue())
print >> log
print >> log, "A logfile named %s was created." % (
params.outlier_utils.output.logfile)
print >> log, "This logfile contains the screen output and"
print >> log, "(possibly) some ccp4 style loggraph plots"
def reindex_utils(args):
if len(args)==0:
print_help()
elif ( "--help" in args ):
print_help()
elif ( "--h" in args ):
print_help()
elif ("-h" in args ):
print_help()
else:
log = multi_out()
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="map_coefs")
print >> log, "#phil __OFF__"
print >> log, "================="
print >> log, " REINDEX "
print >> log, "A reindexing tool"
print >> log, "================="
print >> log
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
if not arg_is_processed:
print >> log, "##----------------------------------------------##"
print >> log, "## Unknown file or keyword:", arg
print >> log, "##----------------------------------------------##"
print >> log
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params_root = effective_params.extract()
params = params_root.reindex_utils
# now get the unit cell from the files
hkl_xs = None
pdb_xs = None
if params.input.xray_data.file_name is not None:
hkl_xs = crystal_symmetry_from_any.extract_from(
file_name=params.input.xray_data.file_name)
if params.input.model.file_name is not None:
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.input.model.file_name)
phil_xs = crystal.symmetry(
unit_cell=params.input.unit_cell,
space_group_info=params.input.space_group )
combined_xs = crystal.select_crystal_symmetry(
None,phil_xs, [pdb_xs],[hkl_xs])
# inject the unit cell and symmetry in the phil scope please
params.input.unit_cell = combined_xs.unit_cell()
params.input.space_group = combined_xs.space_group_info()
print >> log, "#phil __ON__"
new_params = master_params.format(python_object=params_root)
new_params.show(out=log)
print >> log, "#phil __END__"
if params.input.unit_cell is None:
raise Sorry("unit cell not specified")
if params.input.space_group is None:
raise Sorry("space group not specified")
#-----------------------------------------------------------
#
# step 1: read in the reflection file
#
miller_array = None
if params.input.xray_data.file_name is not None:
phil_xs = crystal.symmetry(
unit_cell=params.input.unit_cell,
space_group_info=params.input.space_group )
xray_data_server = reflection_file_utils.reflection_file_server(
crystal_symmetry = phil_xs,
force_symmetry = True,
reflection_files=[])
miller_array = xray_data_server.get_xray_data(
file_name = params.input.xray_data.file_name,
labels = params.input.xray_data.labels,
ignore_all_zeros = True,
parameter_scope = 'reindex_utils.input.xray_data',
parameter_name = 'labels'
)
info = miller_array.info()
miller_array = miller_array.map_to_asu()
miller_array = miller_array.select(
miller_array.indices() != (0,0,0))
miller_array = miller_array.select(
miller_array.data() > 0 )
if miller_array.sigmas() is not None:
miller_array = miller_array.select(
miller_array.sigmas() > 0 )
if (miller_array.is_xray_intensity_array()):
miller_array = miller_array.f_sq_as_f()
elif (miller_array.is_complex_array()):
miller_array = abs(miller_array)
miller_array.set_info(info)
print >> log
print >> log, "Summary info of observed data"
print >> log, "============================="
miller_array.show_summary(f=log)
print >> log
#----------------------------------------------------------------
# Step 2: get an xray structure from the PDB file
#
pdb_model = None
if params.input.model.file_name is not None:
pdb_model = iotbx.pdb.input(
file_name=params.input.model.file_name)
model = pdb_model.xray_structure_simple(crystal_symmetry=phil_xs)
print >> log, "Atomic model summary"
print >> log, "===================="
model.show_summary()
print >> log
if params.parameters.action=="reindex":
#----------------------------------------------------------------
# step 3: get the reindex laws
to_niggli = phil_xs.change_of_basis_op_to_niggli_cell()
to_reference = phil_xs.change_of_basis_op_to_reference_setting()
to_inverse = phil_xs.change_of_basis_op_to_inverse_hand()
cb_op = None
pr = params.parameters.reindex
if (pr.standard_laws == "niggli"):
cb_op = to_niggli
elif (pr.standard_laws == "reference_setting"):
cb_op = to_reference
elif (pr.standard_laws == "invert"):
cb_op = to_inverse
else:
cb_op = sgtbx.change_of_basis_op(pr.user_supplied_law)
if cb_op is None:
raise Sorry("No change of basis operation is supplied.")
if params.parameters.inverse:
cb_op = cb_op.inverse()
print >> log, "Supplied reindexing law:"
print >> log, "========================"
print >> log, "hkl notation: ", cb_op.as_hkl()
print >> log, "xyz notation: ", cb_op.as_xyz()
print >> log, "abc notation: ", cb_op.as_abc()
#----------------------------------------------------------------
# step 4: do the reindexing
#
# step 4a: first do the miller array object
new_miller_array = None
if miller_array is not None:
new_miller_array = miller_array.change_basis( cb_op )
#
# step 4b: the xray structure
new_model = None
if pdb_model is not None:
new_model = model.change_basis( cb_op )
#----------------------------------------------------------------
# step 5a: write the new mtz file
print >> log
print >> log, "The data and model have been reindexed"
print >> log, "--------------------------------------"
print >> log
print >> log, "Writing output files...."
if miller_array is not None:
print >> log, "writing mtz file with name %s" % (params.output.hklout)
mtz_dataset = new_miller_array.as_mtz_dataset(
column_root_label="FOBS")
mtz_dataset.mtz_object().write(file_name=params.output.hklout)
#step 5b: write the new pdb file
if new_model is not None:
pdb_file = open(params.output.xyzout, 'w')
print >> log, "Wring pdb file to: %s" % params.output.xyzout
write_as_pdb_file(
input_pdb = pdb_model,
input_xray_structure = new_model,
out = pdb_file,
chain_id_increment = params.parameters.chain_id_increment,
additional_remark = "Generated by mmtbx reindex")
print >> pdb_file, "END"
pdb_file.close()
if ( [miller_array,new_model]).count(None)==2:
print >>log, "No input reflection of coordinate files have been given"
if params.parameters.action=="operator":
rt_mx = sgtbx.rt_mx(
params.parameters.apply_operator.user_supplied_operator,t_den=12*8 )
if params.parameters.inverse:
rt_mx = rt_mx.inverse()
print >> log
print >> log, "Applied operator : ", rt_mx.as_xyz()
print >> log
sites = model.sites_frac()
new_sites = flex.vec3_double()
for site in sites:
new_site = rt_mx.r()*matrix.col(site)
new_site = flex.double(new_site)+flex.double( rt_mx.t().as_double() )
new_sites.append( tuple(new_site) )
new_model = model.deep_copy_scatterers()
new_model.set_sites_frac( new_sites )
# write the new [pdb file please
pdb_file = open(params.output.xyzout, 'w')
print >> log, "Wring pdb file to: %s" % params.output.xyzout
if params.parameters.apply_operator.concatenate_model:
write_as_pdb_file(
input_pdb = pdb_model,
input_xray_structure = model,
out = pdb_file,
chain_id_increment = 0,
additional_remark = None,
print_cryst_and_scale=True)
write_as_pdb_file(
input_pdb = pdb_model,
input_xray_structure = new_model,
out = pdb_file,
chain_id_increment = params.parameters.chain_id_increment,
additional_remark = None,
print_cryst_and_scale=False)
print >> pdb_file, "END"
pdb_file.close()
if params.parameters.action=="manipulate_pdb":
#rest all the b values
if params.parameters.manipulate_pdb.set_b:
b_iso = params.reindex_utils.parameters.manipulate_pdb.b_iso
new_model = model.set_b_iso( value = b_iso )
print >> log
print >> log, "All B-values have been set to %5.3f"%(b_iso)
print >> log, "Writing PDB file %s"%(params.output.xyzout)
print >> log
pdb_file = open(params.output.xyzout, 'w')
write_as_pdb_file(
input_pdb = pdb_model,
input_xray_structure = new_model,
out = pdb_file,
chain_id_increment = 0,
additional_remark = None,
print_cryst_and_scale=True)
print >> pdb_file, "END"
pdb_file.close()
#write the logfile
logger = open(params.output.logfile, 'w')
print >> log, "Writing log file with name %s" % params.output.logfile
print >> log
print >> logger, string_buffer.getvalue()
def get_reflection_file_server(self,
filenames=None,
labels=None,
array_type=None,
crystal_symmetry=None,
force_symmetry=None,
logger=None):
'''
Return the file server for a single miller_array file or mulitple files
:param filenames: list of filenames or None
:param labels: list of lists of labels or None
:param array_type: "x_ray", "neutron", "electron", or None
:param crystal_symmetry: cctbx.crystal.symmetry object or None
:param force_symmetry: bool or None
:param logger: defaults to self.logger (multi_out)
The order in filenames and labels should match, e.g. labels[0] should be the
labels for filenames[0]. The lengths of filenames and labels should be equal
as well. If all the labels in a file are to be added, set the labels entry
to None, e.g. labels[0] = None.
If array_type is None, files of any type are allowed.
'''
# use default logger if no logger for reflection_file_server is provided
if logger is None:
logger = self.logger
# use default miller_array file if no filenames provided
if filenames is None:
default_filename = self._check_miller_array_default_filename(
'miller_array')
filenames = [default_filename]
# set labels
if labels is None:
labels = [None for filename in filenames]
assert len(filenames) == len(labels)
# force crystal symmetry if a crystal symmetry is provided
if crystal_symmetry is not None and force_symmetry is None:
force_symmetry = True
if force_symmetry is None:
force_symmetry = False
# determine crystal symmetry from file list, if not provided
if crystal_symmetry is None:
try:
from_reflection_files = []
for filename, file_labels in zip(filenames, labels):
miller_arrays = self.get_miller_arrays(filename=filename)
for miller_array in miller_arrays:
if ((file_labels is None)
or (miller_array.info().label_string()
in file_labels)):
from_reflection_files.append(
miller_array.crystal_symmetry())
crystal_symmetry = crystal.select_crystal_symmetry(
from_reflection_files=from_reflection_files)
except Exception:
raise Sorry(
'A unit cell and space group could not be determined from the "filenames" argument. Please make sure there are enough data arrays being selected.'
)
# crystal_symmetry and force_symmetry should be set by now
miller_arrays = []
for filename, file_labels in zip(filenames, labels):
file_arrays = self.get_miller_array(filename).\
as_miller_arrays(crystal_symmetry=crystal_symmetry,
force_symmetry=force_symmetry)
if file_labels is None:
file_labels = self.get_miller_array_labels(filename)
for miller_array in file_arrays:
label_name = miller_array.info().label_string()
# check array label
if label_name in file_labels:
# check array type
if (array_type is None
or array_type == self.get_miller_array_type(
filename, label_name)):
miller_arrays.append(miller_array)
file_server = reflection_file_server(crystal_symmetry=crystal_symmetry,
force_symmetry=force_symmetry,
miller_arrays=miller_arrays,
err=logger)
return file_server
def run(args, command_name="phenix.xmanip"):
if (len(args) == 0 or "--help" in args or "--h" in args or "-h" in args):
print_help(command_name=command_name)
else:
log = multi_out()
if (not "--quiet" in args):
log.register(label="stdout", file_object=sys.stdout)
string_buffer = StringIO()
string_buffer_plots = StringIO()
log.register(label="log_buffer", file_object=string_buffer)
phil_objects = []
argument_interpreter = master_params.command_line_argument_interpreter(
home_scope="map_coefs")
print >> log, "#phil __OFF__"
print >> log, "=========================="
print >> log, " XMANIP "
print >> log, "reindexing and other tasks"
print >> log, "=========================="
print >> log
for arg in args:
command_line_params = None
arg_is_processed = False
# is it a file?
if (os.path.isfile(arg)): ## is this a file name?
# check if it is a phil file
try:
command_line_params = iotbx.phil.parse(file_name=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
else:
try:
command_line_params = argument_interpreter.process(arg=arg)
if command_line_params is not None:
phil_objects.append(command_line_params)
arg_is_processed = True
except KeyboardInterrupt: raise
except Exception : pass
if not arg_is_processed:
print >> log, "##----------------------------------------------##"
print >> log, "## Unknown file or keyword:", arg
print >> log, "##----------------------------------------------##"
print >> log
raise Sorry("Unknown file or keyword: %s" % arg)
effective_params = master_params.fetch(sources=phil_objects)
params = effective_params.extract()
# now get the unit cell from the files
hkl_xs = []
pdb_xs = None
#multiple file names are allowed
for xray_data in params.xmanip.input.xray_data:
if xray_data.file_name is not None:
hkl_xs.append( crystal_symmetry_from_any.extract_from(
file_name=xray_data.file_name) )
if params.xmanip.input.model.file_name is not None:
pdb_xs = crystal_symmetry_from_any.extract_from(
file_name=params.xmanip.input.model.file_name)
phil_xs = crystal.symmetry(
unit_cell=params.xmanip.input.unit_cell,
space_group_info=params.xmanip.input.space_group )
combined_xs = crystal.select_crystal_symmetry(
None,phil_xs, [pdb_xs],hkl_xs)
if combined_xs is not None:
# inject the unit cell and symmetry in the phil scope please
params.xmanip.input.unit_cell = combined_xs.unit_cell()
params.xmanip.input.space_group = \
sgtbx.space_group_info( group = combined_xs.space_group() )
print >> log, "#phil __ON__"
new_params = master_params.format(python_object=params)
new_params.show(out=log)
print >> log, "#phil __END__"
if params.xmanip.input.unit_cell is None:
raise Sorry("unit cell not specified")
if params.xmanip.input.space_group is None:
raise Sorry("space group not specified")
#-----------------------------------------------------------
#
# step 1: read in the reflection file
#
miller_arrays = []
labels = []
label_appendix = []
write_it = []
names = {}
if len(params.xmanip.input.xray_data)>0:
phil_xs = crystal.symmetry(
unit_cell=params.xmanip.input.unit_cell,
space_group_info=params.xmanip.input.space_group )
xray_data_server = reflection_file_utils.reflection_file_server(
crystal_symmetry = phil_xs,
force_symmetry = True,
reflection_files=[])
count=0
for xray_data in params.xmanip.input.xray_data:
if xray_data.file_name is not None:
miller_array = None
miller_array = read_data(xray_data.file_name,
xray_data.labels,
phil_xs)
print >> log
print >> log, "Summary info of observed data"
print >> log, "============================="
if miller_array is None:
raise Sorry("Failed to read data. see errors above" )
miller_array.show_summary(f=log)
print >> log
miller_arrays.append( miller_array )
labels.append( miller_array.info().labels )
label_appendix.append( xray_data.label_appendix )
this_name = "COL_"+str(count)
if xray_data.name is not None:
this_name = xray_data.name
#check if this name is allready used
if names.has_key( this_name ):
raise Sorry( "Non unique dataset name. Please change the input script" )
names.update( {this_name:count} )
count += 1
write_it.append( xray_data.write_out)
output_label_root = construct_output_labels( labels, label_appendix )
for ii in range(len(labels)):
test=0
for jj in range( ii+1,len(labels) ):
for lab_name1, lab_name2 in zip(labels[ii],labels[jj]):
if lab_name1==lab_name2:
test+=1
if test == 2:
print >> log, "\n***** You are trying to import the data with label(s) %s more then one time. ***** \n"%(str(labels[ii]))
for ii in range(len(output_label_root)):
for jj in range(ii+1,len(output_label_root)):
if output_label_root[ii]==output_label_root[jj]:
if write_it[ii]:
if write_it[jj]:
print >> log, "Output label roots:"
print >> log, output_label_root
raise Sorry( "Output labels are not unique. Modify input." )
#----------------------------------------------------------------
# Step 2: get an xray structure from the PDB file
#
pdb_model = None
model = None
if params.xmanip.input.model.file_name is not None:
pdb_model = iotbx.pdb.input(
file_name=params.xmanip.input.model.file_name)
model = pdb_model.xray_structure_simple(crystal_symmetry=phil_xs)
print >> log, "Atomic model summary"
print >> log, "===================="
model.show_summary(f=log)
print >> log
write_miller_array = False
write_pdb_file = False
# define some output holder thingamebobs
new_miller_arrays = []
new_model = None
#manipulate miller arrays
if params.xmanip.parameters.action == "manipulate_miller":
write_miller_array = True
new_miller = xmanip_tasks.manipulate_miller(names,
miller_arrays,
model,
params.xmanip.parameters.manipulate_miller,
log )
miller_arrays.append( new_miller )
# not very smart to rely here on a phil defintion defined in another file
tmp_root = params.xmanip.parameters.manipulate_miller.output_label_root
if tmp_root is None:
tmp_root = "UNSPECIFIED"
output_label_root.append( tmp_root )
write_it.append(True)
if params.xmanip.parameters.action=="reindex":
write_miller_array = True
#----------------------------------------------------------------
# step 3: get the reindex laws
phil_xs.show_summary()
to_niggli = phil_xs.change_of_basis_op_to_niggli_cell()
to_reference = phil_xs.change_of_basis_op_to_reference_setting()
to_inverse = phil_xs.change_of_basis_op_to_inverse_hand()
to_primitive = phil_xs.change_of_basis_op_to_primitive_setting()
cb_op = None
if (params.xmanip.parameters.reindex.standard_laws == "niggli"):
cb_op = to_niggli
if (params.xmanip.parameters.reindex.standard_laws == "reference_setting"):
cb_op = to_reference
if (params.xmanip.parameters.reindex.standard_laws == "invert"):
cb_op = to_inverse
if (params.xmanip.parameters.reindex.standard_laws == "user_supplied"):
cb_op = sgtbx.change_of_basis_op( params.xmanip.parameters.reindex.user_supplied_law )
if (params.xmanip.parameters.reindex.standard_laws == "primitive_setting"):
cb_op = to_primitive
if cb_op is None:
raise Sorry("No change of basis operation is supplied.")
print >> log, "Supplied reindexing law:"
print >> log, "========================"
print >> log, "hkl notation: ", cb_op.as_hkl()
print >> log, "xyz notation: ", cb_op.as_xyz()
print >> log, "abc notation: ", cb_op.as_abc()
#----------------------------------------------------------------
# step 4: do the reindexing
#
# step 4a: first do the miller array object
#new_miller_arrays = []
for miller_array in miller_arrays:
new_miller_array = None
if miller_array is not None:
new_miller_array = miller_array.change_basis( cb_op )
new_miller_arrays.append( new_miller_array )
#
# step 4b: the xray structure
if pdb_model is not None:
write_pdb_file=True
new_model = model.change_basis( cb_op )
if write_miller_array:
if len(new_miller_arrays)==0:
new_miller_arrays = miller_arrays
#----------------------------------------------------------------
print >> log
print >> log, "The data has been reindexed/manipulated"
print >> log, "--------------------------------------"
print >> log
print >> log, "Writing output files...."
mtz_dataset=None
if len(new_miller_arrays)>0:
first=0
for item in range(len(write_it)):
if write_it[item]:
first=item
if new_miller_arrays[ first ] is not None:
break
if new_miller_arrays[first] is not None:
tmp = new_miller_arrays[first].map_to_asu()
mtz_dataset = tmp.as_mtz_dataset(
column_root_label=output_label_root[first])
if mtz_dataset is not None:
for miller_array, new_root in zip(new_miller_arrays[first+1:],
output_label_root[first+1:]):
if miller_array is not None:
mtz_dataset = mtz_dataset.add_miller_array(
miller_array = miller_array,
column_root_label = new_root)
print >> log, "Writing mtz file with name %s"%(params.xmanip.output.hklout)
mtz_dataset.mtz_object().write(
file_name=params.xmanip.output.hklout)
#step 5b: write the new pdb file
if new_model is not None:
pdb_file = open( params.xmanip.output.xyzout, 'w')
print >> log, "Wring pdb file to: %s"%(params.xmanip.output.xyzout)
write_as_pdb_file(
input_pdb = pdb_model,
input_xray_structure = new_model,
out = pdb_file,
chain_id_increment= 0,
additional_remark = "Generated by %s" % command_name)
pdb_file.close()
if ( [miller_array,new_model]).count(None)==2:
print >>log, "No input reflection of coordinate files have been given"
if params.xmanip.parameters.action=="manipulate_pdb":
if params.xmanip.parameters.manipulate_pdb.task == "apply_operator":
rt_mx = None
if params.xmanip.parameters.manipulate_pdb.apply_operator.standard_operators == "user_supplied_operator":
rt_mx = sgtbx.rt_mx(
params.xmanip.parameters.manipulate_pdb.apply_operator.user_supplied_operator,t_den=12*8 )
print >> log, "Applied operator : ", rt_mx.as_xyz()
if params.xmanip.parameters.manipulate_pdb.apply_operator.standard_operators == \
"user_supplied_cartesian_rotation_matrix":
rt = params.xmanip.parameters.manipulate_pdb.apply_operator.user_supplied_cartesian_rotation_matrix
tmp_r=None
tmp_t=None
if "," in rt.r:
tmp_r = rt.r.split(',')
else:
tmp_r = rt.r.split(' ')
if "," in rt.r:
tmp_t = rt.t.split(',')
else:
tmp_t = rt.t.split(' ')
tmp_tmp_r=[]
tmp_tmp_t=[]
for item in tmp_r:
tmp_tmp_r.append( float(item) )
if len(tmp_tmp_r)!=9:
raise Sorry("Invalid rotation matrix. Please check input: %s"%(rt.r) )
for item in tmp_t:
tmp_tmp_t.append( float(item) )
if len(tmp_tmp_t)!=3:
raise Sorry("Invalid translational vector. Please check input: %s"%(rt.t) )
tmp_tmp_t = (tmp_tmp_t)
rt_mx = quick_rt_mx(tmp_tmp_r, tmp_tmp_t)
print >> log, "User supplied cartesian matrix and vector: "
rt_mx.show()
o = matrix.sqr(model.unit_cell().orthogonalization_matrix())
tmp_r = o.inverse()*rt_mx.r()*o
tmp_t = o.inverse()*matrix.col(list(rt_mx.t()))
print >> log
print >> log, "Operator in fractional coordinates: "
rt_mx = quick_rt_mx(r=tmp_r.as_float(), t=list(tmp_t))
rt_mx.show(out=log)
print >> log
if params.xmanip.parameters.manipulate_pdb.apply_operator.invert:
rt_mx = rt_mx.inverse()
print >> log
print >> log, "Taking inverse of given operator"
print >> log
sites = model.sites_frac()
new_sites = flex.vec3_double()
for site in sites:
new_site = rt_mx.r()*matrix.col(site)
new_site = flex.double(new_site)+flex.double( rt_mx.t().as_double() )
new_sites.append( tuple(new_site) )
new_model = model.deep_copy_scatterers()
new_model.set_sites_frac( new_sites )
# write the new [pdb file please
pdb_file = open( params.xmanip.output.xyzout, 'w')
print >> log, "Wring pdb file to: %s"%(params.xmanip.output.xyzout)
if params.xmanip.parameters.manipulate_pdb.apply_operator.concatenate_model:
write_as_pdb_file( input_pdb = pdb_model,
input_xray_structure = model,
out = pdb_file,
chain_id_increment = 0,
additional_remark = None,
print_cryst_and_scale=True )
write_as_pdb_file( input_pdb = pdb_model,
input_xray_structure = new_model,
out = pdb_file,
chain_id_increment = params.xmanip.parameters.manipulate_pdb.apply_operator.chain_id_increment,
additional_remark = None,
print_cryst_and_scale=False )
pdb_file.close()
if params.xmanip.parameters.manipulate_pdb.task =="set_b":
#rest all the b values
if params.xmanip.parameters.manipulate_pdb.set_b:
b_iso = params.xmanip.parameters.manipulate_pdb.b_iso
new_model = model.set_b_iso( value = b_iso )
print >> log
print >> log, "All B-values have been set to %5.3f"%(b_iso)
print >> log, "Writing PDB file %s"%(params.xmanip.output.xyzout)
print >> log
pdb_file = open( params.xmanip.output.xyzout, 'w')
write_as_pdb_file( input_pdb = pdb_model,
input_xray_structure = new_model,
out = pdb_file,
chain_id_increment = 0,
additional_remark = None,
print_cryst_and_scale=True)
pdb_file.close()
#write the logfile
logger = open( params.xmanip.output.logfile, 'w')
print >> log, "Writing log file with name %s "%(params.xmanip.output.logfile)
print >> logger, string_buffer.getvalue()[0:len(string_buffer.getvalue())-1] #avoid a newline at the end ...
logger.close()
