void EMFit::output(std::string out_file_name, std::string out_pdb_file_name) {
std::ofstream out_file(out_file_name.c_str());
out_file << "receptorPdb (str) " << rec_file_name_ << std::endl;
out_file << "ligandPdb (str) " << lig_file_name_ << std::endl;
EM3DFitResult::print_header(out_file);
out_file.setf(std::ios::fixed, std::ios::floatfield);
out_file.setf(std::ios::right, std::ios::adjustfield);
IMP::algebra::Vector3Ds lig_points;
IMP::saxs::get_coordinates(lig_particles_, lig_points);
for (unsigned int i = 0; i < fit_results_.size(); i++) {
out_file << fit_results_[i] << std::endl;
}
out_file.close();
if (fit_results_.size() == 1) { // output PDB
IMP::algebra::Transformation3D tr = fit_results_[0].get_map_trans();
IMP::Particles ps = rec_particles_;
ps.insert(ps.end(), lig_particles_.begin(), lig_particles_.end());
// transform
for (IMP::Particles::iterator it = ps.begin(); it != ps.end();
it++) {
IMP::core::XYZ d(*it);
d.set_coordinates(tr * d.get_coordinates());
}
// output
std::ofstream out_file2(out_pdb_file_name.c_str());
IMP::ParticlesTemp pst = ps;
IMP::atom::write_pdb(pst, out_file2);
out_file2.close();
}
}
void get_residue_solvent_accessibility(const IMP::Particles& atom_particles,
const IMP::Particles& residue_particles,
const std::vector<int>& atom_2_residue_map,
std::vector<float>& residue_solvent_accessibility) {
IMP::saxs::FormFactorTable* ft = IMP::saxs::default_form_factor_table();
IMP::saxs::FormFactorType ff_type = IMP::saxs::HEAVY_ATOMS;
for(unsigned int i=0; i<atom_particles.size(); i++) {
float radius = ft->get_radius(atom_particles[i], ff_type);
IMP::core::XYZR::setup_particle(atom_particles[i], 2.0*radius);
}
IMP::Floats surface_area;
IMP::saxs::SolventAccessibleSurface s;
surface_area = s.get_solvent_accessibility(IMP::core::XYZRs(atom_particles));
// sum up individual atom areas into residue area
residue_solvent_accessibility.clear();
residue_solvent_accessibility.insert(residue_solvent_accessibility.begin(),
residue_particles.size(), 0.0);
for(unsigned int i=0; i<atom_particles.size(); i++) {
// convert from 0-1 range to actual area in A^2
float radius = IMP::core::XYZR(atom_particles[i]).get_radius();
float area = surface_area[i] * 4*IMP::algebra::PI*radius*radius;
residue_solvent_accessibility[atom_2_residue_map[i]] += area;
}
// compute solvent accessability percentage
std::map<IMP::atom::ResidueType, float> residue_type_area_map_;
residue_type_area_map_[IMP::atom::ALA] = 113.0;
residue_type_area_map_[IMP::atom::ARG] = 241.0;
residue_type_area_map_[IMP::atom::ASP] = 151.0;
residue_type_area_map_[IMP::atom::ASN] = 158.0;
residue_type_area_map_[IMP::atom::CYS] = 140.0;
residue_type_area_map_[IMP::atom::GLN] = 189.0;
residue_type_area_map_[IMP::atom::GLU] = 183.0;
residue_type_area_map_[IMP::atom::GLY] = 85.0;
residue_type_area_map_[IMP::atom::HIS] = 194.0;
residue_type_area_map_[IMP::atom::ILE] = 182.0;
residue_type_area_map_[IMP::atom::LEU] = 180.0;
residue_type_area_map_[IMP::atom::LYS] = 211.0;
residue_type_area_map_[IMP::atom::MET] = 204.0;
residue_type_area_map_[IMP::atom::PHE] = 218.0;
residue_type_area_map_[IMP::atom::PRO] = 143.0;
residue_type_area_map_[IMP::atom::SER] = 122.0;
residue_type_area_map_[IMP::atom::THR] = 146.0;
residue_type_area_map_[IMP::atom::TYR] = 229.0;
residue_type_area_map_[IMP::atom::TRP] = 259.0;
residue_type_area_map_[IMP::atom::VAL] = 160.0;
residue_type_area_map_[IMP::atom::UNK] = 113.0;
for(unsigned int i=0; i<residue_particles.size(); i++) {
IMP::atom::ResidueType residue_type =
IMP::atom::Residue(residue_particles[i]).get_residue_type();
float residue_area = residue_type_area_map_.find(residue_type)->second;
std::cerr << residue_type.get_string() << " "
<< residue_solvent_accessibility[i]
<< " " << residue_area << std::endl;
residue_solvent_accessibility[i] /= residue_area;
}
}
void get_atom_2_residue_map(const IMP::Particles& atom_particles,
const IMP::Particles& residue_particles,
std::vector<int>& atom_2_residue_map) {
atom_2_residue_map.resize(atom_particles.size());
unsigned int residue_index=0;
for(unsigned int atom_index=0; atom_index<atom_particles.size(); ) {
if(get_residue(IMP::atom::Atom(atom_particles[atom_index])).get_particle()
== residue_particles[residue_index]) {
atom_2_residue_map[atom_index] = residue_index;
atom_index++;
} else {
residue_index++;
}
}
}
void read_pdb_ca_atoms(const std::string file_name, IMP::Particles& particles) {
IMP::Model *model = new IMP::Model();
IMP::atom::Hierarchy mhd = IMP::atom::read_pdb(file_name, model,
new IMP::atom::CAlphaPDBSelector(), true, true);
particles=IMP::get_as<IMP::Particles>(get_by_type(mhd, IMP::atom::ATOM_TYPE));
std::cout << "Number of CA atom particles " << particles.size() << std::endl;
}
void EMFit::read_pdb_atoms(IMP::Model* model,
const std::string file_name,
IMP::Particles& particles) {
IMP::atom::Hierarchy mhd = IMP::atom::read_pdb(
file_name, model, new IMP::atom::NonWaterNonHydrogenPDBSelector(), true,
true);
particles = get_by_type(mhd, IMP::atom::ATOM_TYPE);
std::cout << "Number of atom particles " << particles.size() << std::endl;
}
void get_residue_solvent_accessibility(const IMP::Particles& residue_particles,
IMP::Floats& residue_solvent_accessibility) {
IMP::saxs::FormFactorTable* ft = IMP::saxs::default_form_factor_table();
IMP::saxs::FormFactorType ff_type = IMP::saxs::CA_ATOMS;
for(unsigned int p_index=0; p_index<residue_particles.size(); p_index++) {
float radius = ft->get_radius(residue_particles[p_index], ff_type);
IMP::core::XYZR::setup_particle(residue_particles[p_index], radius);
}
IMP::saxs::SolventAccessibleSurface s;
residue_solvent_accessibility =
s.get_solvent_accessibility(IMP::core::XYZRs(residue_particles));
}
float EMFit::compute_volume(const IMP::Particles& particles) {
IMP::saxs::FormFactorTable* ft = IMP::saxs::get_default_form_factor_table();
float volume = 0.0;
float c = (4.0 / 3.0) * IMP::algebra::PI;
for (unsigned int pindex = 0; pindex < particles.size(); pindex++) {
float radius = ft->get_radius(particles[pindex]);
// volume = 4/3 * pi * r^3
volume += c * radius * radius * radius;
// add radius to particle. it is needed later for sampled density map
IMP::core::XYZR::setup_particle(particles[pindex], radius);
}
return volume;
}
IMP::algebra::Vector3D get_ca_coordinate(const IMP::Particles& ca_atoms,
int residue_index,
std::string chain_id) {
IMP::algebra::Vector3D v(0, 0, 0);
for (unsigned int i = 0; i < ca_atoms.size(); i++) {
IMP::atom::Residue r = IMP::atom::get_residue(IMP::atom::Atom(ca_atoms[i]));
int curr_residue_index = r.get_index();
std::string curr_chain_id =
IMP::atom::get_chain_id(IMP::atom::Atom(ca_atoms[i]));
if (curr_residue_index == residue_index && curr_chain_id == chain_id) {
IMP::algebra::Vector3D v = IMP::core::XYZ(ca_atoms[i]).get_coordinates();
return v;
}
}
std::cerr << "Residue not found " << residue_index << " " << chain_id
<< std::endl;
exit(1);
// return v;
}
void transform(IMP::Particles& ps, IMP::algebra::Transformation3D& t) {
for(IMP::Particles::iterator it = ps.begin(); it != ps.end(); it++) {
IMP::core::XYZ d(*it);
d.set_coordinates(t * d.get_coordinates());
}
}
int main(int argc, char **argv) {
// output arguments
for (int i = 0; i < argc; i++) std::cerr << argv[i] << " ";
std::cerr << std::endl;
double end_q_rg = 1.3;
po::options_description desc(
"Usage: <pdb_file1> <pdb_file2> \
... <profile_file1> <profile_file2> ...");
desc.add_options()("help",
"Any number of input PDBs and profiles is supported. \
Each PDB will be fitted against each profile.")(
"input-files", po::value<std::vector<std::string> >(),
"input PDB and profile files")(
"end_q_rg,q*rg", po::value<double>(&end_q_rg)->default_value(1.3),
"end q*rg value for rg computation, q*rg<end_q_rg (default = 1.3), \
use 0.8 for elongated proteins");
po::positional_options_description p;
p.add("input-files", -1);
po::variables_map vm;
po::store(
po::command_line_parser(argc, argv).options(desc).positional(p).run(),
vm);
po::notify(vm);
std::vector<std::string> files, pdb_files, dat_files;
if (vm.count("input-files")) {
files = vm["input-files"].as<std::vector<std::string> >();
}
if (vm.count("help") || files.size() == 0) {
std::cout << desc << "\n";
return 0;
}
// 1. read pdbs and profiles, prepare particles
IMP::Model *model = new IMP::Model();
IMP::Vector<IMP::Particles> particles_vec;
IMP::Vector<IMP::saxs::Profile *> exp_profiles;
for (unsigned int i = 0; i < files.size(); i++) {
// check if file exists
std::ifstream in_file(files[i].c_str());
if (!in_file) {
std::cerr << "Can't open file " << files[i] << std::endl;
exit(1);
}
// A. try as pdb
try {
IMP::atom::Hierarchy mhd = IMP::atom::read_pdb(
files[i], model, new IMP::atom::NonWaterNonHydrogenPDBSelector(),
// don't add radii
true, true);
IMP::Particles particles =
IMP::get_as<IMP::Particles>(get_by_type(mhd,
IMP::atom::ATOM_TYPE));
if (particles.size() > 0) { // pdb file
pdb_files.push_back(files[i]);
particles_vec.push_back(particles);
std::cout << particles.size() << " atoms were read from PDB file "
<< files[i] << std::endl;
}
}
catch (IMP::ValueException e) { // not a pdb file
// B. try as dat file
IMP::saxs::Profile *profile = new IMP::saxs::Profile(files[i]);
if (profile->size() == 0) {
std::cerr << "can't parse input file " << files[i] << std::endl;
return 1;
} else {
dat_files.push_back(files[i]);
exp_profiles.push_back(profile);
std::cout << "Profile read from file " << files[i]
<< " size = " << profile->size() << std::endl;
}
}
}
// 2. compute rg for input profiles
for (unsigned int i = 0; i < dat_files.size(); i++) {
IMP::saxs::Profile *exp_saxs_profile = exp_profiles[i];
double rg = exp_saxs_profile->radius_of_gyration(end_q_rg);
std::cout << dat_files[i] << " Rg= " << rg << std::endl;
}
// 3. compute rg for input pdbs
for (unsigned int i = 0; i < pdb_files.size(); i++) {
double rg = IMP::saxs::radius_of_gyration(particles_vec[i]);
std::cout << pdb_files[i] << " Rg= " << rg << std::endl;
}
return 0;
}
