void read_files(Model *m, const std::vector<std::string>& files, std::vector<std::string>& pdb_file_names, std::vector<std::string>& dat_files, std::vector<IMP::Particles>& particles_vec, Profiles& exp_profiles, bool residue_level, bool heavy_atoms_only, int multi_model_pdb, bool explicit_water, float max_q, int units) { for (unsigned int i = 0; i < files.size(); i++) { // check if file exists std::ifstream in_file(files[i].c_str()); if (!in_file) { IMP_WARN("Can't open file " << files[i] << std::endl); return; } // 1. try as pdb try { read_pdb(m, files[i], pdb_file_names, particles_vec, residue_level, heavy_atoms_only, multi_model_pdb, explicit_water); } catch (const IMP::ValueException &e) { // not a pdb file // 2. try as a dat profile file IMP_NEW(Profile, profile, (files[i], false, max_q, units)); if (profile->size() == 0) { IMP_WARN("can't parse input file " << files[i] << std::endl); return; } else { dat_files.push_back(files[i]); exp_profiles.push_back(profile); IMP_LOG_TERSE("Profile read from file " << files[i] << " size = " << profile->size() << std::endl); } } } }
IMPATOM_BEGIN_INTERNAL_NAMESPACE void add_dihedral_to_list(const CHARMMParameters *param, kernel::Particle *p1, kernel::Particle *p2, kernel::Particle *p3, kernel::Particle *p4, kernel::Particles &ps) { try { base::Vector<CHARMMDihedralParameters> p = param->get_dihedral_parameters( CHARMMAtom(p1).get_charmm_type(), CHARMMAtom(p2).get_charmm_type(), CHARMMAtom(p3).get_charmm_type(), CHARMMAtom(p4).get_charmm_type()); for (base::Vector<CHARMMDihedralParameters>::const_iterator it = p.begin(); it != p.end(); ++it) { Dihedral dd = Dihedral::setup_particle( new kernel::Particle(p1->get_model()), core::XYZ(p1), core::XYZ(p2), core::XYZ(p3), core::XYZ(p4)); dd.set_ideal(it->ideal / 180.0 * PI); dd.set_multiplicity(it->multiplicity); if (it->force_constant < 0.0) { dd.set_stiffness(-std::sqrt(-it->force_constant * 2.0)); } else { dd.set_stiffness(std::sqrt(it->force_constant * 2.0)); } ps.push_back(dd); } } catch (const base::IndexException &e) { // If no parameters, warn, and create an empty dihedral IMP_WARN(e.what() << std::endl); Dihedral dd = Dihedral::setup_particle( new kernel::Particle(p1->get_model()), core::XYZ(p1), core::XYZ(p2), core::XYZ(p3), core::XYZ(p4)); ps.push_back(dd); } }
LoadLink::~LoadLink() { if (!frame_loaded_) { IMP_WARN("No frames were loaded from file \"" << get_name() << "\" even though objects were linked or created." << std::endl); } }
SaveLink::~SaveLink() { if (!frame_saved_) { IMP_WARN("No frames were saved to file \"" << get_name() << "\" even though objects were added." << std::endl); } }
double WeightedExcludedVolumeRestraint::unprotected_evaluate( DerivativeAccumulator *accum) const { bool calc_deriv = accum? true: false; IMP_LOG_VERBOSE("before resample\n"); // //generate the transformed maps // std::vector<DensityMap*> transformed_maps; // for(int rb_i=0;rb_i<rbs_.size();rb_i++){ // DensityMap *dm=create_density_map( // atom::get_bounding_box(atom::Hierarchy(rbs_[rb_i])),spacing); // get_transformed_into( // rbs_surface_maps_[rb_i], // rbs_[rb_i].get_transformation()*rbs_orig_trans_[rb_i], // dm, // false); // transformed_maps.push_back(dm); // } double score=0.; // MRCReaderWriter mrw; // for(int i=0;i<transformed_maps.size();i++){ // std::stringstream ss; // ss<<"transformed_map_"<<i<<".mrc"; // std::stringstream s1; // s1<<"transformed_pdb_"<<i<<".pdb"; // atom::write_pdb(atom::Hierarchy(rbs_[i]),s1.str().c_str()); // write_map(transformed_maps[i],ss.str().c_str(),mrw); // for(int j=i+1;j<transformed_maps.size();j++){ // if (get_interiors_intersect(transformed_maps[i], // transformed_maps[j])){ // score += CoarseCC::cross_correlation_coefficient( // *transformed_maps[i], // *transformed_maps[j],1.,false,true); // } // } // } em::SurfaceShellDensityMaps resampled_surfaces; for(unsigned int i=0; i<rbs_.size(); i++) { kernel::ParticlesTemp rb_ps=rb_refiner_->get_refined(rbs_[i]); resampled_surfaces.push_back(new em::SurfaceShellDensityMap(rb_ps,1.)); } for(unsigned int i=0; i<rbs_.size(); i++) { for(unsigned int j=i+1; j<rbs_.size(); j++) { if (get_interiors_intersect(resampled_surfaces[i], resampled_surfaces[j])) { score += em::CoarseCC::cross_correlation_coefficient( resampled_surfaces[i], resampled_surfaces[j],1.,true,FloatPair(0.,0.)); } } } if (calc_deriv) { IMP_WARN("WeightedExcludedVolumeRestraint currently" <<" does not support derivatives\n"); } /*for(int i=resampled_surfaces.size()-1;i<0;i--){ delete(resampled_surfaces[i]); }*/ return score; }
SettingsData *read_settings(const char *filename) { std::fstream in; in.open(filename, std::fstream::in); if (!in.good()) { IMP_THROW("Problem opening file " << filename << " for reading " << std::endl, ValueException); } std::string line; IMP_NEW(SettingsData, header, ()); getline(in, line); // skip header line int status = 0; while (!in.eof()) { getline(in, line); // skip header line std::vector<std::string> line_split; boost::split(line_split, line, boost::is_any_of("|")); if ((line_split.size() == 10) && (status == 0)) { // protein line IMP_LOG_VERBOSE("parsing component line:" << line << std::endl); header->add_component_header(parse_component_line(filename, line)); } else if (status == 0) { // map header line status = 1; } else if (status == 1) { // map line IMP_LOG_VERBOSE("parsing EM line:" << line << std::endl); header->set_assembly_header(parse_assembly_line(filename, line)); status = 2; } else if (line.length() > 0) { // don't warn about empty lines IMP_WARN("the line was not parsed:" << line << "| with status:" << status << std::endl); } } in.close(); header->set_assembly_filename(filename); header->set_data_path("."); return header.release(); }
void load_union(const Subset &s0, const Subset &s1, AssignmentContainer *nd0, AssignmentContainer *nd1, const EdgeData &ed, double max_error, ParticleStatesTable* pst, const statistics::Metrics &metrics, unsigned int max, AssignmentContainer *out) { Ints ii0= get_index(s0, ed.intersection_subset); Ints ii1= get_index(s1, ed.intersection_subset); Ints ui0= get_index(ed.union_subset, s0); Ints ui1= get_index(ed.union_subset, s1); Ints uii= get_index(ed.union_subset, ed.intersection_subset); Assignments nd1a = nd1->get_assignments(IntRange(0, nd1->get_number_of_assignments())); // chunck outer and writing later unsigned int nd0sz= nd0->get_number_of_assignments(); for (unsigned int i=0; i< nd0sz; ++i) { Assignment nd0a=nd0->get_assignment(i); Assignment nd0ae=get_sub_assignment(nd0a, ii0); for (unsigned int j=0; j< nd1a.size(); ++j) { Assignment nd1ae=get_sub_assignment(nd1a[j], ii1); bool merged_ok=(nd1ae==nd0ae); Assignment ss; if (!merged_ok && pst) {; double n= get_distance_if_smaller_than(ed.intersection_subset, nd0ae, nd1ae, pst, metrics, max_error); if ( n < max_error) { merged_ok=true; } } if (merged_ok) { ss= get_merged_assignment(ed.union_subset, nd0a, ui0, nd1a[j], ui1); } if (merged_ok) { bool ok=true; for (unsigned int k=0; k< ed.filters.size(); ++k) { if (ed.filters[k]->get_is_ok(ss)) { // pass } else { ok=false; break; } } if (ok) { out->add_assignment(ss); if (out->get_number_of_assignments() > max) { IMP_WARN("Truncated number of states at " << max << " when merging " << s0 << " and " << s1); return; } } } } } }
IMPBASE_BEGIN_NAMESPACE #if IMP_HAS_LOG void WarningContext::add_warning(std::string key, std::string warning) const { if (warning.empty()) return; #if IMP_HAS_LOG >= IMP_WARN if (data_.find(key) == data_.end()) { data_.insert(key); IMP_WARN(warning); } #endif }
double EnvelopePenetrationRestraint::unprotected_evaluate( DerivativeAccumulator *accum) const { Float ret_score; ret_score = get_number_of_particles_outside_of_the_density( target_dens_map_, ps_, IMP::algebra::get_identity_transformation_3d(), threshold_); if (accum != nullptr) { IMP_WARN( "No derivatives have been assigned to the envelope penetration " "score\n"); } return ret_score; }
double DensityFillingRestraint::unprotected_evaluate( DerivativeAccumulator *accum) const { double ret_score; double covered_percentage = get_percentage_of_voxels_covered_by_particles( target_dens_map_, ps_, core::XYZR(ps_[0]).get_radius(), IMP::algebra::get_identity_transformation_3d(), threshold_); ret_score = 1. - covered_percentage; if (accum != nullptr) { IMP_WARN( "No derivatives have been assigned to the envelope penetration " "score\n"); } return ret_score; }
const RadiusDependentKernelParameters& KernelParameters::get_params( float radius, float eps) { IMP_USAGE_CHECK(initialized_, "The Kernel Parameters are not initialized"); typedef std::map<float, const RadiusDependentKernelParameters*> kernel_map; //we do not use find but use lower_bound and upper_bound to overcome //numerical instabilities //in maps, an iterator that addresses the location of an element //that with a key that is equal to or greater than the argument key, //or that addresses the location succeeding the last element in the //map if no match is found for the key. kernel_map::iterator lower_closest = radii2params_.lower_bound(radius); kernel_map::iterator upper_closest = radii2params_.upper_bound(radius); const RadiusDependentKernelParameters *closest = nullptr; if (algebra::get_are_almost_equal(radius,upper_closest->first,eps)) { closest = upper_closest->second; IMP_LOG_VERBOSE("for radius:"<<radius<< " the closest is:"<< upper_closest->first<<std::endl); } else { if (lower_closest != radii2params_.end()) { if (algebra::get_are_almost_equal(radius,lower_closest->first,eps)) { closest = lower_closest->second; } } } if (closest == nullptr) { IMP_WARN("could not find parameters for radius:"<<radius<<std::endl); IMP_WARN("Setting params for radius :"<<radius<<std::endl); return set_params(radius); } else { return *closest; } }
double Optimizer::optimize(unsigned int max_steps) { IMP_OBJECT_LOG; if (!scoring_function_) { IMP_WARN("No scoring function provided - using Model's implicit " "scoring function (deprecated). Recommend you use a " "ScoringFunction object instead." << std::endl); } set_has_required_score_states(true); set_was_used(true); set_is_optimizing_states(true); double ret; IMP_THREADS((ret, max_steps), { ret = do_optimize(max_steps); });
double RadiusOfGyrationRestraint::unprotected_evaluate(DerivativeAccumulator *accum) const { IMP_UNUSED(accum); //IMP_USAGE_CHECK(!accum, "No derivatives computed"); if (accum) { IMP_WARN("Can not calcaulte derivatives\n"); } //calculate actual rog //todo - do not use get_input_particles function float actual_rog=get_actual_radius_of_gyration(get_input_particles()); IMP_LOG_VERBOSE("actual_rog:"<<actual_rog<<" predicted:"<<predicted_rog_<< " scale:"<<predicted_rog_*scale_<<" score: "<< hub_->evaluate(actual_rog)<<std::endl); return hub_->evaluate(actual_rog); }
void Projection::init(const IMP::algebra::Vector3Ds& points, double max_radius, int axis_size) { // determine the image size needed to store the projection x_min_ = y_min_ = std::numeric_limits<float>::max(); x_max_ = y_max_ = std::numeric_limits<float>::min(); // determine translation to center algebra::Vector3D center(0.0, 0.0, 0.0); for (unsigned int i = 0; i < points.size(); i++) { x_min_ = std::min(x_min_, points[i][0]); y_min_ = std::min(y_min_, points[i][1]); x_max_ = std::max(x_max_, points[i][0]); y_max_ = std::max(y_max_, points[i][1]); center += points[i]; } center /= points.size(); static IMP::em::KernelParameters kp(resolution_); const IMP::em::RadiusDependentKernelParameters& params = kp.get_params(max_radius); double wrap_length = 2 * params.get_kdist() + 1.0; x_min_ = x_min_ - wrap_length - scale_; y_min_ = y_min_ - wrap_length - scale_; x_max_ = x_max_ + wrap_length + scale_; y_max_ = y_max_ + wrap_length + scale_; int width = (int)((x_max_ - x_min_) / scale_ + 2); int height = (int)((y_max_ - y_min_) / scale_ + 2); int size = std::max(width, height); // the determined size should be below axis size if specified if (axis_size > 0 && size <= axis_size) size = axis_size; else { IMP_WARN("wrong size estimate " << size << " vs. estimate " << axis_size << std::endl); } this->resize(boost::extents[size][size]); int i = 0, j = 0; get_index_for_point(center, i, j); t_i_ = size / 2 - i; t_j_ = size / 2 - j; }
FittingSolutionRecords read_fitting_solutions(const char *fitting_fn) { std::fstream in; FittingSolutionRecords sols; in.open(fitting_fn, std::fstream::in); if (! in.good()) { IMP_WARN("Problem opening file " << fitting_fn << " for reading; returning 0 solutions" << std::endl); in.close(); return sols; } std::string line; getline(in, line); //skip header line while (!in.eof()) { if (!getline(in, line)) break; sols.push_back(parse_fitting_line(line)); } in.close(); return sols; }
void CHARMMParameters::add_angle(kernel::Particle *p1, kernel::Particle *p2, kernel::Particle *p3, kernel::Particles &ps) const { IMP_OBJECT_LOG; Angle ad = Angle::setup_particle(new kernel::Particle(p1->get_model()), core::XYZ(p1), core::XYZ(p2), core::XYZ(p3)); try { const CHARMMBondParameters &p = get_angle_parameters( CHARMMAtom(p1).get_charmm_type(), CHARMMAtom(p2).get_charmm_type(), CHARMMAtom(p3).get_charmm_type()); ad.set_ideal(p.ideal / 180.0 * PI); ad.set_stiffness(std::sqrt(p.force_constant * 2.0)); } catch (const base::IndexException &e) { // If no parameters, warn only IMP_WARN(e.what()); } ps.push_back(ad); }
void load_union(const Subset &s0, const Subset &s1, AssignmentContainer *nd0, AssignmentContainer *nd1, const EdgeData &ed, size_t max, AssignmentContainer *out) { Ints ii0 = get_index(s0, ed.intersection_subset); Ints ii1 = get_index(s1, ed.intersection_subset); Ints ui0 = get_index(ed.union_subset, s0); Ints ui1 = get_index(ed.union_subset, s1); Ints uii = get_index(ed.union_subset, ed.intersection_subset); Assignments nd1a = nd1->get_assignments(IntRange(0, nd1->get_number_of_assignments())); // chunck outer and writing later unsigned int nd0sz = nd0->get_number_of_assignments(); IMP_PROGRESS_DISPLAY("Merging subsets " << s0 << " and " << s1, nd0sz * nd1a.size()); for (unsigned int i = 0; i < nd0sz; ++i) { Assignment nd0a = nd0->get_assignment(i); Assignment nd0ae = get_sub_assignment(nd0a, ii0); for (unsigned int j = 0; j < nd1a.size(); ++j) { Assignment nd1ae = get_sub_assignment(nd1a[j], ii1); if (nd1ae == nd0ae) { Assignment ss = get_merged_assignment(ed.union_subset, nd0a, ui0, nd1a[j], ui1); bool ok = true; for (unsigned int k = 0; k < ed.filters.size(); ++k) { if (!ed.filters[k]->get_is_ok(ss)) { ok = false; break; } } if (ok) { out->add_assignment(ss); if (out->get_number_of_assignments() > max) { IMP_WARN("Truncated number of states at " << max << " when merging " << s0 << " and " << s1); return; } } } IMP::base::add_to_progress_display(1); } } }
void set_log_level(LogLevel l) { // snap to max level if (l > IMP_HAS_LOG) { l = LogLevel(IMP_HAS_LOG); } #if IMP_BASE_HAS_LOG4CXX try { switch (l) { case PROGRESS: case SILENT: get_logger()->setLevel(log4cxx::Level::getOff()); break; case WARNING: get_logger()->setLevel(log4cxx::Level::getWarn()); break; case TERSE: get_logger()->setLevel(log4cxx::Level::getInfo()); break; case VERBOSE: get_logger()->setLevel(log4cxx::Level::getDebug()); break; case MEMORY: get_logger()->setLevel(log4cxx::Level::getTrace()); break; case DEFAULT: case ALL_LOG: default: IMP_WARN("Unknown log level " << boost::lexical_cast<std::string>(l)); } } catch (log4cxx::helpers::Exception &) { IMP_THROW("Invalid log level", ValueException); } #else IMP_USAGE_CHECK(l >= SILENT && l < ALL_LOG, "Setting log to invalid level: " << l); #endif IMP_OMP_PRAGMA(critical(imp_log)) if (internal::log_level != l) { internal::log_level = l; } }
core::RigidBody setup_as_rigid_body(Hierarchy h) { IMP_USAGE_CHECK(h.get_is_valid(true), "Invalid hierarchy passed to setup_as_rigid_body"); IMP_WARN("create_rigid_body should be used instead of setup_as_rigid_body" << " as the former allows one to get volumes correct at coarser" << " levels of detail."); core::RigidBody rbd = core::RigidBody::setup_particle(h, get_leaves(h)); rbd.set_coordinates_are_optimized(true); kernel::ParticlesTemp internal = core::get_internal(h); for (unsigned int i = 0; i < internal.size(); ++i) { if (internal[i] != h) { core::RigidMembers leaves(get_leaves(Hierarchy(internal[i]))); if (!leaves.empty()) { algebra::ReferenceFrame3D rf = core::get_initial_reference_frame( get_as<kernel::ParticlesTemp>(leaves)); core::RigidBody::setup_particle(internal[i], rf); } } } IMP_INTERNAL_CHECK(h.get_is_valid(true), "Invalid hierarchy produced"); return rbd; }
ProteinsAnchorsSamplingSpace read_protein_anchors_mapping( multifit::ProteomicsData *prots, const std::string &anchors_prot_map_fn, int max_paths) { ProteinsAnchorsSamplingSpace ret(prots); std::fstream in; IMP_LOG_TERSE("FN:" << anchors_prot_map_fn << std::endl); in.open(anchors_prot_map_fn.c_str(), std::fstream::in); if (!in.good()) { IMP_WARN( "Problem opening file " << anchors_prot_map_fn << " for reading; returning empty mapping data" << std::endl); in.close(); return ret; } std::string line; // first line should be the anchors line getline(in, line); std::string anchors_fn = get_relative_path(anchors_prot_map_fn, parse_anchors_line(line)); IMP_LOG_TERSE("FN:" << anchors_fn << std::endl); multifit::AnchorsData anchors_data = multifit::read_anchors_data(anchors_fn.c_str()); ret.set_anchors(anchors_data); ret.set_anchors_filename(anchors_fn); while (!in.eof()) { if (!getline(in, line)) break; IMP_LOG_VERBOSE("working on line:" << line); IMP_USAGE_CHECK(is_protein_line(line), "the line should be a protein line"); boost::tuple<std::string, std::string, IntsList> prot_data = parse_protein_line(anchors_prot_map_fn, line, max_paths); ret.set_paths_for_protein(boost::get<0>(prot_data), boost::get<2>(prot_data)); ret.set_paths_filename_for_protein(boost::get<0>(prot_data), boost::get<1>(prot_data)); } return ret; }
void handle_error(const char *msg) { static bool is_handling=false; if (is_handling) { return; } is_handling=true; for (int i=internal::handlers.size()-1; i >=0; --i) { IMP_CHECK_OBJECT(internal::handlers[i]); try { internal::handlers[i]->handle_failure(); } catch (const Exception &e) { IMP_WARN("Caught exception in failure handler \"" << internal::handlers[i]->get_name() << "\": " << e.what() << std::endl); } } if (internal::print_exceptions) { IMP_ERROR(msg); } is_handling=false; }
Object::~Object() { IMP_INTERNAL_CHECK( get_is_valid(), "Object " << this << " previously freed " << "but something is trying to delete it again. Make sure " << "that all C++ code uses IMP::Pointer objects to" << " store it."); #if IMP_HAS_CHECKS >= IMP_USAGE // if there is no exception currently being handled warn if it was not owned if (!was_owned_ && !std::uncaught_exception()) { IMP_WARN( "Object \"" << get_name() << "\" was never used." << " See the IMP::Object documentation for an explanation." << std::endl); } #endif #if IMP_HAS_CHECKS >= IMP_INTERNAL remove_live_object(this); #endif IMP_LOG_MEMORY("Destroying object \"" << get_name() << "\" (" << this << ")" << std::endl); #if IMP_HAS_LOG > IMP_NONE && !IMP_BASE_HAS_LOG4CXX // cleanup if (log_level_ != DEFAULT) { IMP::base::set_log_level(log_level_); } #endif IMP_INTERNAL_CHECK(get_ref_count() == 0, "Deleting object which still has references"); #if IMP_HAS_CHECKS >= IMP_USAGE check_value_ = 666666666; #endif #if IMP_HAS_CHECKS >= IMP_INTERNAL --live_objects_; #endif }
IMPATOM_BEGIN_NAMESPACE double get_protein_density_from_reference( ProteinDensityReference density_reference) { double density = 0.625; // ALBER reference switch (density_reference) { // Alber et al. (2005) r = 0.726*std::pow(m, .3333); case ALBER: break; // Harpaz et al. 0.826446=1/1.21 Da/A3 ~ 1.372 g/cm3 case HARPAZ: density = 0.826446; break; // Andersson and Hovmoller (1998) Theoretical 1.22 g/cm3 case ANDERSSON: density = 0.7347; break; // Tsai et al. (1999) Theoretical 1.40 g/cm3 case TSAI: density = 0.84309; break; // Quillin and Matthews (2000) Theoretical 1.43 g/cm3 case QUILLIN: density = 0.86116; break; // Squire and Himmel (1979) and Gekko and Noguchi (1979) Experimental 1.37 case SQUIRE: density = 0.82503; break; // unknown reference; default: IMP_WARN( "unknown density reference... Density set to its default value."); } return density; }
ProteomicsData *read_proteomics_data(const char *prot_fn) { std::fstream in; IMP_NEW(ProteomicsData, data, ()); in.open(prot_fn, std::fstream::in); if (! in.good()) { IMP_WARN("Problem opening file " << prot_fn << " for reading; returning empty proteomics data" << std::endl); in.close(); return data.release(); } std::string line; getline(in, line); //skip proteins header line getline(in, line); //skip proteins header line while ((!in.eof()) && (!is_interaction_header_line(line, data))){ parse_protein_line(line,data); if (!getline(in, line)) break; } getline(in, line); while ((!in.eof()) && (!is_xlink_header_line(line,data))){ parse_interaction_line(line,data); if (!getline(in, line)) break; } getline(in, line); while (!in.eof() && (!is_ev_header_line(line,data))){ parse_xlink_line(line,data); if (!getline(in, line)) break; } getline(in, line); while (!in.eof()) { //ev lines parse_ev_line(line,data); if (!getline(in, line)) break; if (line.size()==0) break; } in.close(); return data.release(); }
void CHARMMPatch::apply(CHARMMResidueTopology *res1, CHARMMResidueTopology *res2) const { if (res1->get_patched()) { IMP_THROW("Cannot patch an already-patched residue", ValueException); } if (res2->get_patched()) { IMP_THROW("Cannot patch an already-patched residue", ValueException); } check_empty_patch(this); // Extra checks for the commonly-used CHARMM DISU patch if (get_type() == "DISU" && (res1->get_type() != "CYS" || res2->get_type() != "CYS")) { IMP_WARN("Applying a DISU patch to two residues that are not both 'CYS' " "(they are " << *res1 << " and " << *res2 << "). This is " "probably not what was intended."); } // Copy or update atoms for (base::Vector<CHARMMAtomTopology>::const_iterator it = atoms_.begin(); it != atoms_.end(); ++it) { std::pair<CHARMMResidueTopology *, CHARMMAtomTopology> resatom = handle_two_patch_atom(*it, res1, res2); try { resatom.first->get_atom(resatom.second.get_name()) = resatom.second; } catch (ValueException &e) { resatom.first->add_atom(resatom.second); } } // Delete atoms for (base::Vector<std::string>::const_iterator it = deleted_atoms_.begin(); it != deleted_atoms_.end(); ++it) { std::pair<CHARMMResidueTopology *, CHARMMAtomTopology> resatom = handle_two_patch_atom(*it, res1, res2); try { resatom.first->remove_atom(resatom.second.get_name()); } catch (ValueException &e) { // ignore atoms that don't exist to start with } } // Add angles/bonds/dihedrals/impropers for (unsigned int i = 0; i < get_number_of_bonds(); ++i) { CHARMMResidueTopology *res = get_two_patch_residue_for_bond(get_bond(i), res1, res2); res->add_bond(CHARMMBond(handle_two_patch_bond(get_bond(i), res1, res2, res))); } for (unsigned int i = 0; i < get_number_of_angles(); ++i) { CHARMMResidueTopology *res = get_two_patch_residue_for_bond(get_angle(i), res1, res2); res->add_angle(CHARMMAngle(handle_two_patch_bond(get_angle(i), res1, res2, res))); } for (unsigned int i = 0; i < get_number_of_dihedrals(); ++i) { CHARMMResidueTopology *res = get_two_patch_residue_for_bond(get_dihedral(i), res1, res2); res->add_dihedral(CHARMMDihedral(handle_two_patch_bond(get_dihedral(i), res1, res2, res))); } for (unsigned int i = 0; i < get_number_of_impropers(); ++i) { CHARMMResidueTopology *res = get_two_patch_residue_for_bond(get_improper(i), res1, res2); res->add_improper(CHARMMDihedral(handle_two_patch_bond(get_improper(i), res1, res2, res))); } // Add internal coordinates for (unsigned int i = 0; i < get_number_of_internal_coordinates(); ++i) { CHARMMInternalCoordinate ic = get_internal_coordinate(i); CHARMMResidueTopology *res = get_two_patch_residue_for_bond(get_internal_coordinate(i), res1, res2); res->add_internal_coordinate( CHARMMInternalCoordinate(handle_two_patch_bond(ic, res1, res2, res), ic.get_first_distance(), ic.get_first_angle(), ic.get_dihedral(), ic.get_second_angle(), ic.get_second_distance(), ic.get_improper())); } res1->set_patched(true); res2->set_patched(true); }
float CoarseCC::local_cross_correlation_coefficient( const DensityMap *em_map, DensityMap *model_map, float voxel_data_threshold) { IMP_INTERNAL_CHECK( model_map->get_header()->dmax > voxel_data_threshold, "voxel_data_threshold: " << voxel_data_threshold << " is not within the map range: " << model_map->get_header()->dmin << "-" << model_map->get_header()->dmax << std::endl); const DensityHeader *model_header = model_map->get_header(); const DensityHeader *em_header = em_map->get_header(); const emreal *em_data = em_map->get_data(); const emreal *model_data = model_map->get_data(); // validity checks IMP_USAGE_CHECK( em_map->same_voxel_size(model_map), "This function cannot handle density maps of different pixelsize. " << "First map pixelsize : " << em_header->get_spacing() << "; " << "Second map pixelsize: " << model_header->get_spacing()); // Check if the model map has zero RMS if ((fabs(model_map->get_header()->rms - 0.0) < EPS)) { IMP_WARN("The model map rms is zero, and the user ask to divide" << " by rms. returning 0!" << std::endl); return 0.0; } long nvox = em_header->get_number_of_voxels(); ; emreal ccc = 0.0; emreal model_mean = 0.; emreal em_mean = 0.; emreal model_rms = 0.; emreal em_rms = 0.; IMP_LOG_VERBOSE("calc local CC with different origins" << std::endl); model_map->get_header_writable()->compute_xyz_top(); // Given the same size of the maps and the dimension order, the difference // between two positions in voxels is always the same // calculate the difference in voxels between the origin of the model map // and the origin of the em map. float voxel_size = em_map->get_header()->get_spacing(); int ivoxx_shift = (int)floor( (model_header->get_xorigin() - em_header->get_xorigin()) / voxel_size); int ivoxy_shift = (int)floor( (model_header->get_yorigin() - em_header->get_yorigin()) / voxel_size); int ivoxz_shift = (int)floor( (model_header->get_zorigin() - em_header->get_zorigin()) / voxel_size); long j; // Index for em data long i; // Index for model data // calculate the shift in index of the origin of model_map in em_map // ( j can be negative) j = ivoxz_shift * em_header->get_nx() * em_header->get_ny() + ivoxy_shift * em_header->get_nx() + ivoxx_shift; int num_elements = 0; // for (i = 0; i < nvox; i++) { // if the voxel of the model is above the threshold if (model_data[i] > voxel_data_threshold) { // Check if the voxel belongs to the em map volume, and only then // compute the correlation if (j + i >= 0 && j + i < nvox) { num_elements++; em_mean += em_data[j + i]; model_mean += model_data[i]; } } } em_mean = em_mean / num_elements; model_mean = model_mean / num_elements; em_rms = 0.; model_rms = 0.; for (i = 0; i < nvox; i++) { // if the voxel of the model is above the threshold if (model_data[i] > voxel_data_threshold) { // Check if the voxel belongs to the em map volume, and only then // compute the correlation if (j + i >= 0 && j + i < nvox) { ccc += (em_data[j + i] - em_mean) * (model_data[i] - model_mean); em_rms += (em_data[j + i] - em_mean) * (em_data[j + i] - em_mean); model_rms += (model_data[i] - model_mean) * (model_data[i] - model_mean); } } } em_rms = std::sqrt(em_rms / num_elements); model_rms = std::sqrt(model_rms / num_elements); IMP_INTERNAL_CHECK(num_elements > 0, "No voxels participated in the calculation" << " may be that the voxel_data_threshold:" << voxel_data_threshold << " is off" << std::endl); ccc = ccc / (1. * num_elements * em_rms * model_rms); IMP_LOG_VERBOSE(" local ccc : " << ccc << " voxel# " << num_elements << " norm factors (map,model) " << em_rms << " " << model_rms << " means(map,model) " << em_mean << " " << model_mean << std::endl); return ccc; }
algebra::Vector3Ds CoarseCC::calc_derivatives(const DensityMap *em_map, const DensityMap *model_map, const Particles &model_ps, const FloatKey &w_key, KernelParameters *kernel_params, const float &scalefac, const algebra::Vector3Ds &dv) { algebra::Vector3Ds dv_out; dv_out.insert(dv_out.end(), dv.size(), algebra::Vector3D(0., 0., 0.)); double tdvx = 0., tdvy = 0., tdvz = 0., tmp, rsq; int iminx, iminy, iminz, imaxx, imaxy, imaxz; const DensityHeader *model_header = model_map->get_header(); const DensityHeader *em_header = em_map->get_header(); const float *x_loc = em_map->get_x_loc(); const float *y_loc = em_map->get_y_loc(); const float *z_loc = em_map->get_z_loc(); IMP_INTERNAL_CHECK(model_ps.size() == dv.size(), "input derivatives array size does not match " << "the number of particles in the model map\n"); core::XYZRs model_xyzr = core::XYZRs(model_ps); // this would go away once we have XYZRW decorator const emreal *em_data = em_map->get_data(); float lim = kernel_params->get_lim(); long ivox; // validate that the model and em maps are not empty IMP_USAGE_CHECK(em_header->rms >= EPS, "EM map is empty ! em_header->rms = " << em_header->rms); if (model_header->rms <= EPS) { IMP_WARN("Model map is empty ! model_header->rms = " << model_header->rms << " derivatives are not calculated. the model centroid is : " << core::get_centroid(core::XYZs(model_ps)) << " the map centroid is " << em_map->get_centroid() << "number of particles in model:"<<model_ps.size() << std::endl); return dv_out; } // Compute the derivatives int nx = em_header->get_nx(); int ny = em_header->get_ny(); // int nz=em_header->get_nz(); IMP_INTERNAL_CHECK(em_map->get_rms_calculated(), "RMS should be calculated for calculating derivatives \n"); long nvox = em_header->get_number_of_voxels(); double lower_comp = 1. * nvox * em_header->rms * model_header->rms; for (unsigned int ii = 0; ii < model_ps.size(); ii++) { float x, y, z; x = model_xyzr[ii].get_x(); y = model_xyzr[ii].get_y(); z = model_xyzr[ii].get_z(); IMP_IF_LOG(VERBOSE) { algebra::Vector3D vv(x, y, z); IMP_LOG_VERBOSE( "start value:: (" << x << "," << y << "," << z << " ) " << em_map->get_value(x, y, z) << " : " << em_map->get_dim_index_by_location(vv, 0) << "," << em_map->get_dim_index_by_location(vv, 1) << "," << em_map->get_dim_index_by_location(vv, 2) << std::endl); } calc_local_bounding_box( // em_map, model_map, x, y, z, kernel_params->get_rkdist(), iminx, iminy, iminz, imaxx, imaxy, imaxz); IMP_LOG_VERBOSE("local bb: [" << iminx << "," << iminy << "," << iminz << "] [" << imaxx << "," << imaxy << "," << imaxz << "] \n"); tdvx = .0; tdvy = .0; tdvz = .0; for (int ivoxz = iminz; ivoxz <= imaxz; ivoxz++) { for (int ivoxy = iminy; ivoxy <= imaxy; ivoxy++) { ivox = ivoxz * nx * ny + ivoxy * nx + iminx; for (int ivoxx = iminx; ivoxx <= imaxx; ivoxx++) { /* if (em_data[ivox]<EPS) { ivox++; continue; }*/ float dx = x_loc[ivox] - x; float dy = y_loc[ivox] - y; float dz = z_loc[ivox] - z; rsq = dx * dx + dy * dy + dz * dz; rsq = EXP(-rsq * kernel_params->get_inv_rsigsq()); tmp = (x - x_loc[ivox]) * rsq; if (std::abs(tmp) > lim) { tdvx += tmp * em_data[ivox]; } tmp = (y - y_loc[ivox]) * rsq; if (std::abs(tmp) > lim) { tdvy += tmp * em_data[ivox]; } tmp = (z - z_loc[ivox]) * rsq; if (std::abs(tmp) > lim) { tdvz += tmp * em_data[ivox]; } ivox++; } } } tmp = model_ps[ii]->get_value(w_key) * 2. * kernel_params->get_inv_rsigsq() * scalefac * kernel_params->get_rnormfac() / lower_comp; IMP_LOG_VERBOSE("for particle:" << ii << " (" << tdvx << "," << tdvy << "," << tdvz << ")" << std::endl); dv_out[ii][0] = tdvx * tmp; dv_out[ii][1] = tdvy * tmp; dv_out[ii][2] = tdvz * tmp; } // particles return dv_out; }