Exemple #1
0
GtkTreeModel *
get_filter_model (gboolean first)
{
  GtkTreeModelFilter *model;

  model = (GtkTreeModelFilter *)gtk_tree_model_filter_new (get_model (), NULL);

  gtk_tree_model_filter_set_visible_func (model, visible_func, GINT_TO_POINTER (first), NULL);

  return (GtkTreeModel *) model;
}
ParticleIndexes DummyPairContainer::get_all_possible_indexes() const {
  kernel::ParticleIndexes ret = c_->get_all_possible_indexes();
  kernel::ModelObjectsTemp mos =
      cpf_->get_inputs(get_model(), c_->get_indexes());
  for (unsigned int i = 0; i < mos.size(); ++i) {
    kernel::ModelObject *o = mos[i];
    kernel::Particle *p = dynamic_cast<kernel::Particle *>(o);
    if (p) ret.push_back(p->get_index());
  }
  return ret;
}
void MolecularDynamics::propagate_coordinates(const ParticleIndexes &ps,
                                              double ts) {
  for (unsigned int i = 0; i < ps.size(); ++i) {
    Float invmass = 1.0 / Mass(get_model(), ps[i]).get_mass();
    core::XYZ d(get_model(), ps[i]);
    LinearVelocity v(get_model(), ps[i]);
    algebra::Vector3D coord = d.get_coordinates();
    algebra::Vector3D dcoord = d.get_derivatives();
    // calculate velocity at t+(delta t/2) from that at t
    algebra::Vector3D velocity = v.get_velocity();
    velocity += 0.5 * dcoord * deriv_to_acceleration * invmass * ts;
    for (unsigned int j = 0; j < 3; ++j) {
      cap_velocity_component(velocity[j]);
    }
    v.set_velocity(velocity);

    // calculate position at t+(delta t) from that at t
    coord += velocity * ts;
    d.set_coordinates(coord);
  }
}
Exemple #4
0
//
// Function:	ffll_close_model()
// 
// Purpose:		Closes the model for the index passed in.
//
// Arguments:	
//
//		int		model_idx	- index of the model 
//
// Returns:
//
//		0 - success
//		non-zero - failure
//
// Author:	Michael Zarozinski
// Date:	2/02
// 
// Modification History
//	Author		Date		Modification
//	------		----		------------
//	Michael Z	4/15/03		Ignore null model... 
//  
int WIN_FFLL_API ffll_close_model(int model_idx)
{
	ModelContainer* container = get_model(model_idx);

	if (container->model != NULL)
		return 0;

 	delete container;

	return 0;
 
}; // end ffll_close_model()
Exemple #5
0
int main(int argc ,char * argv[]){
        int model;
        char target_path[max_len];
        //char* buf;
        //system("./terminal.sh");
        //buf=getenv("VAR_CLOUMS");
        //printf("%s\n",buf);
        init_screen();
        get_model(argc,argv,&model,target_path);
        my_ls(target_path,model);
        return 0;
}
Exemple #6
0
void TransformMover::do_reject() {
  //RigidBody d(get_model(), pi_);
  //d.set_reference_frame(algebra::ReferenceFrame3D(last_transformation_));
  //last_transformation_ = algebra::Transformation3D();
  for (unsigned int i=0;i<pixyzs_.size();i++) {
       core::XYZ d(get_model(), pixyzs_[i]);
       d.set_coordinates(xyzs_[i]);
       //core::transform(d,c_);       
       //core::transform(d,t_.get_inverse());
       //core::transform(d,c_.get_inverse());     
  }

  for (unsigned int i=0;i<pirbs_.size();i++){
      core::RigidBody d(get_model(), pirbs_[i]);
      d.set_reference_frame(algebra::ReferenceFrame3D(rbts_[i]));
      //core::transform(d,c_);       
      //core::transform(d,t_.get_inverse());
      //core::transform(d,c_.get_inverse()); 
  }
  
}
void
ModelManager::set_node_defaults_( index model_id,
  const DictionaryDatum& params )
{
  params->clear_access_flags();

  get_model( model_id )->set_status( params );

  ALL_ENTRIES_ACCESSED( *params,
    "ModelManager::set_node_defaults_",
    "Unread dictionary entries: " );
}
Exemple #8
0
ParticleIndexPairs BondPairContainer::get_range_indexes() const {
  ParticleIndexes ia = sc_->get_range_indexes();
  ParticleIndexPairs ret;
  ret.reserve(ia.size());
  for (unsigned int i = 0; i < ia.size(); ++i) {
    Bond b(get_model(), ia[i]);
    ret.push_back(
        ParticleIndexPair(b.get_bonded(0).get_particle_index(),
                                  b.get_bonded(1).get_particle_index()));
  }
  return ret;
}
ModelObjectsTemp WeightedExcludedVolumeRestraint::do_get_inputs() const
{
    kernel::ModelObjectsTemp ret
        = rb_refiner_->get_inputs(get_model(),
                                  IMP::get_indexes(kernel::ParticlesTemp(particles_begin(),
                                          particles_end())));
    for (ParticleConstIterator it= particles_begin();
            it != particles_end(); ++it) {
        kernel::ParticlesTemp curr= rb_refiner_->get_refined(*it);
        ret += curr;
    }
    return ret;
}
Exemple #10
0
// -------------------------------------------------------------
// animated, mobile object for adventure map
// -------------------------------------------------------------
void t_actor::set_direction( t_direction direction )
{
	t_model const& model = get_model();

	on_move_begin();
	m_direction = direction;
	m_current_sequence = model.get_sequence_cache( m_action, m_direction ).get();
	m_frame_count = model.get_frame_count( m_action, m_direction );
	if (m_frame_count <= m_frame)
		m_frame = m_frame_count - 1;
	m_start_time = get_time();
	on_move_end();
}
Exemple #11
0
/* Apply the pair score to each particle pair listed in the container.
 */
void ExampleRestraint::do_add_score_and_derivatives(ScoreAccumulator sa)
    const {
  IMP_OBJECT_LOG;
  core::XYZ d(get_model(), p_);
  IMP_LOG_VERBOSE("The z coordinate of " << d->get_name() << " is " << d.get_z()
                                         << std::endl);
  double score = .5 * k_ * square(d.get_z());
  if (sa.get_derivative_accumulator()) {
    double deriv = k_ * d.get_z();
    d.add_to_derivative(2, deriv, *sa.get_derivative_accumulator());
  }
  sa.add_score(score);
}
Exemple #12
0
void ModelObject::validate_inputs() const {
  if (!get_has_dependencies()) return;
  IMP_IF_CHECK(USAGE_AND_INTERNAL) {
    ModelObjectsTemp ret = do_get_inputs();
    std::sort(ret.begin(), ret.end());
    ret.erase(std::unique(ret.begin(), ret.end()), ret.end());
    // since I/O nodes are considered outputs
    ModelObjectsTemp saved = get_model()->get_dependency_graph_inputs(this) +
                             get_model()->get_dependency_graph_outputs(this);
    std::sort(saved.begin(), saved.end());
    ModelObjectsTemp intersection;
    std::set_intersection(saved.begin(), saved.end(), ret.begin(), ret.end(),
                          std::back_inserter(intersection));
    IMP_USAGE_CHECK(
        intersection.size() == ret.size(),
        "Dependencies changed without invalidating dependencies."
            << " Make sure you call set_has_dependencies(false) any "
            << "time the list of dependencies changed. Object is " << get_name()
            << " of type " << get_type_name() << " -- " << ret << " vs "
            << saved);
  }
}
Exemple #13
0
IMPISD_BEGIN_NAMESPACE

// MarginalNOERestraint::MarginalNOERestraint() {}

// add a contribution: simple case
void MarginalNOERestraint::add_contribution(Particle *p1,
                                            Particle *p2, double Iexp) {
  ParticleIndexPair pc(p1->get_index(), p2->get_index());
  ParticleIndexPairs pct(1, pc);
  IMP_NEW(container::ListPairContainer, cont, (get_model(), pct));
  // container::ListPairContainer cont(pct);
  add_contribution(cont, Iexp);
}
void InternalDynamicListTripletContainer
::remove_particle_triplets(const ParticleTripletsTemp &c) {
  if (c.empty()) return;
  get_model()->reset_dependencies();
  ParticleIndexTriplets cp= IMP::internal::get_index(c);
  remove_from_list(cp);
  IMP_IF_CHECK(base::USAGE) {
    for (unsigned int i=0; i< c.size(); ++i) {
      IMP_USAGE_CHECK(IMP::internal::is_valid(c[i]),
                    "Passed Triplet cannot be nullptr (or None)");
    }
  }
}
/* Apply the restraint to two atoms, two Scales, one experimental value.
 */
double
AmbiguousNOERestraint::unprotected_evaluate(DerivativeAccumulator *accum) const
{
  IMP_OBJECT_LOG;
  IMP_USAGE_CHECK(get_model(),
                  "You must at least register the restraint with the model"
                  << " before calling evaluate.");

  /* compute Icalc = 1/(gamma*d^6) where d = (sum d_i^-6)^(-1/6) */
  double vol = 0;
  Floats vols;
  IMP_CONTAINER_FOREACH(PairContainer, pc_,
                        {
            core::XYZ d0(get_model(), _1[0]);
            core::XYZ d1(get_model(), _1[1]);
            algebra::Vector3D c0 = d0.get_coordinates();
            algebra::Vector3D c1 = d1.get_coordinates();
            //will raise an error if c0 == c1
            double tmp = 1.0/(c0-c1).get_squared_magnitude();
            vols.push_back(IMP::cube(tmp)); // store di^-6
            vol += vols.back();
                        });
Exemple #16
0
void NaviModules::on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::SelectionData& selection_data, guint info, guint time)
{
    // Combining full path to module
    GtkTreeRowReference* grr = (GtkTreeRowReference*) context->get_data(Glib::Quark("gtk-tree-view-source-row"));
    Gtk::TreeRowReference rr = Glib::wrap(grr);
    Gtk::TreePath path = rr.get_path();
    Glib::RefPtr<Gtk::TreeModel> mdl = get_model();
    Gtk::TreeIter it = mdl->get_iter(path);
    string modname = (*it).get_value(iColRec.name);
    string modpath = iDesEnv->Provider()->ModulesPath();
    string data = "file:" + modpath + modname + "#";
    selection_data.set_text(data);
}
Exemple #17
0
//
// Function:	ffll_new_child()
// 
// Purpose:		Create a new child for the model passed in.
//
// Arguments:	
//
//		int		model_idx	- index of the model 
//
// Returns:
//
//		The index of the child for the model
//		non-zero - failure
//
// Author:	Michael Zarozinski
// Date:	9/01
// 
// Modification History
// Author	Date		Modification
// ------	----		------------
//
//  
int WIN_FFLL_API ffll_new_child(int model_idx)
{
	ModelContainer* container = get_model(model_idx);

	assert(container->model != NULL); // make sure you call ffll_load_fcl_file() before this func.

	ModelChild* child = new ModelChild(container->model);
 
	container->child_list.push_back(child);

	return container->child_list.size() - 1;
 
}; // end ffll_get_child()
Exemple #18
0
double MonteCarlo::do_optimize(unsigned int max_steps) {
    IMP_OBJECT_LOG;
    IMP_CHECK_OBJECT(this);
    if (get_number_of_movers() == 0) {
        IMP_THROW("Running MonteCarlo without providing any"
                  << " movers isn't very useful.",
                  ValueException);
    }

    ParticleIndexes movable = get_movable_particles();

    // provide a way of feeding in this value
    last_energy_ = do_evaluate(movable);
    if (return_best_) {
        best_ = new Configuration(get_model());
        best_energy_ = last_energy_;
    }
    reset_statistics();
    update_states();

    IMP_LOG_TERSE("MC Initial energy is " << last_energy_ << std::endl);

    for (unsigned int i = 0; i < max_steps; ++i) {
        if (get_stop_on_good_score() &&
                get_scoring_function()->get_had_good_score()) {
            break;
        }
        do_step();
        if (best_energy_ < get_score_threshold()) break;
    }

    IMP_LOG_TERSE("MC Final energy is " << last_energy_ << std::endl);
    if (return_best_) {
        // std::cout << "Final score is " << get_model()->evaluate(false)
        //<< std::endl;
        best_->swap_configuration();
        IMP_LOG_TERSE("MC Returning energy " << best_energy_ << std::endl);
        IMP_IF_CHECK(USAGE) {
            IMP_LOG_TERSE("MC Got " << do_evaluate(get_movable_particles())
                          << std::endl);
            /*IMP_INTERNAL_CHECK((e >= std::numeric_limits<double>::max()
                                && best_energy_ >= std::numeric_limits<double>::max())
                               || std::abs(best_energy_ - e)
                               < .01+.1* std::abs(best_energy_ +e),
                               "Energies do not match "
                               << best_energy_ << " vs " << e << std::endl);*/
        }

        return do_evaluate(movable);
    } else {
        return last_energy_;
Exemple #19
0
MonteCarloMoverResult NormalMover::do_propose() {
  IMP_OBJECT_LOG;
  boost::normal_distribution<double> mrng(0, stddev_);
  boost::variate_generator<RandomNumberGenerator &,
                           boost::normal_distribution<double> >
      sampler(random_number_generator, mrng);

  for (unsigned int i = 0; i < pis_.size(); ++i) {
    for (unsigned int j = 0; j < keys_.size(); ++j) {
      originals_[i][j] = get_model()->get_attribute(keys_[j], pis_[i]);
    }
    for (unsigned int j = 0; j < keys_.size(); ++j) {
      IMP_USAGE_CHECK(
          get_model()->get_is_optimized(keys_[j], pis_[i]),
          "NormalMover can't move non-optimized attribute. "
              << "particle: " << get_model()->get_particle_name(pis_[i])
              << "attribute: " << keys_[j]);
      get_model()->set_attribute(keys_[j], pis_[i],
                                 originals_[i][j] + sampler());
    }
  }
  return MonteCarloMoverResult(pis_, 1.0);
}
Exemple #20
0
bool MolecularDynamics::get_is_simulation_particle(ParticleIndex pi) const {
  Particle *p=get_model()->get_particle(pi);
  bool ret=IMP::core::XYZ::particle_is_instance(p)
    && IMP::core::XYZ(p).get_coordinates_are_optimized()
    && Mass::particle_is_instance(p);
  if (ret) {
    for (unsigned int i=0; i< 3; ++i) {
      if (!p->has_attribute(vs_[i])) {
        p->add_attribute(vs_[i], 0.0, false);
      }
    }
  }
  return ret;
}
Exemple #21
0
double WIN_FFLL_API ffll_get_output_value(int model_idx, int child_idx)
{
	ModelContainer* container = get_model(model_idx);

	// get the child
	ModelChild* child = container->child_list[child_idx];

	// pass in the input value for each input variable and the array
	// of DOMs for the output sets
	RealType out_val = container->model->calc_output(child->var_idx_arr, child->out_set_dom_arr); 

	return out_val;
 
}; // end ffll_get_output_value()
Exemple #22
0
//
// Function:	ffll_set_value()
// 
// Purpose:		Set the variable's index for the value passed in.
//
// Arguments:	
//
//		int			model_idx	- index of the model 
//		int			child_idx	- index of the child
//		int			var_idx		- index of the variable
//		RealType	value		- value to set the variable to
//
// Returns:
//
//		0 - success
//		non-zero - failure
//
// Author:	Michael Zarozinski
// Date:	9/01
// 
// Modification History
// Author	Date		Modification
// ------	----		------------
//
//  
int WIN_FFLL_API ffll_set_value(int model_idx, int child_idx, int var_idx, double value)
{
	ModelContainer* container = get_model(model_idx);

	ModelChild* child = container->child_list[child_idx];

	// convert value to an index into the values[] array
	ValuesArrCountType idx = container->model->convert_value_to_idx(var_idx, value);
 		
	child->var_idx_arr[var_idx] = idx;

	return 0;
 
}; // end ffll_set_value()
IncrementalScoringFunction::Data IncrementalScoringFunction::create_data(
    ParticleIndex pi, RestraintsTemp cr,
    const boost::unordered_map<Restraint *, int> &all,
    const Restraints &dummies) const {
  IMP_LOG_TERSE("Dependent restraints for particle "
                << get_model()->get_particle_name(pi) << " are " << cr
                << std::endl);
  Data ret;
  for (unsigned int j = 0; j < cr.size(); ++j) {
    if (all.find(cr[j]) != all.end()) {
      int index = all.find(cr[j])->second;
      IMP_INTERNAL_CHECK(
          std::find(ret.indexes.begin(), ret.indexes.end(), index) ==
              ret.indexes.end(),
          "Found duplicate restraint " << Showable(cr[j]) << " in list " << cr);
      ret.indexes.push_back(index);
    }
  }
  cr += RestraintsTemp(dummies.begin(), dummies.end());
  ret.sf = new IncrementalRestraintsScoringFunction(
      cr, 1.0, NO_MAX, get_model()->get_particle_name(pi) + " restraints");
  return ret;
}
bool MolecularDynamics::get_is_simulation_particle(ParticleIndex pi)
    const {
  Particle *p = get_model()->get_particle(pi);
  bool ret = IMP::core::XYZ::get_is_setup(p) &&
             IMP::core::XYZ(p).get_coordinates_are_optimized() &&
             Mass::get_is_setup(p);
  if (ret) {
    IMP_LOG_VERBOSE(p->get_name() << " is md particle" << std::endl);
    if (!LinearVelocity::get_is_setup(p)) {
      LinearVelocity::setup_particle(p);
    }
  }
  return ret;
}
Exemple #25
0
GtkWidget *
Ekiga::GActorMenu::get_menu (const Ekiga::GActorMenuStore & store)
{
  GMenuModel *model = get_model (store, false);

  if (!model)
    return NULL;

  GtkWidget *menu = gtk_menu_new_from_model (model);
  gtk_widget_insert_action_group (menu, context.c_str (), G_ACTION_GROUP (g_application_get_default ()));
  g_object_ref (menu);

  return menu;
}
Exemple #26
0
double
CAAngleRestraint::unprotected_evaluate(DerivativeAccumulator *) const
{
  Model *m = get_model();
  core::XYZ d0(m, p_[0]);
  core::XYZ d1(m, p_[1]);
  core::XYZ d2(m, p_[2]);

  double phi0 = core::internal::angle(d0, d1, d2, nullptr, nullptr, nullptr);

  int index = get_closest(phi0_,phi0);

  return score_[index];
}
void DistributeQuadsScoreState
::update_lists_if_necessary() const {
  if (updated_ && !input_->get_is_changed()) return;
  updated_=true;

  base::Vector<ParticleIndexQuads> output(data_.size());
  IMP_FOREACH_QUAD_INDEX(input_, {
      for (unsigned int i=0; i< data_.size(); ++i) {
        if (data_[i].get<1>()->get_value_index(get_model(), _1)
            == data_[i].get<2>()) {
          output[i].push_back(_1);
        }
      }
    });
Exemple #28
0
IMPATOM_BEGIN_NAMESPACE

HelixRestraint::HelixRestraint(Residues rs, bool ideal)
    : Restraint(rs[0]->get_model(), "HelixRestraint%1%") {
  //dihedral info
  //Float dih1,std1,dih2,std2,distON,kON;
  Float dih1  = -1.117010721276371; //mean = -64deg, std = 6deg
  Float std1  = 0.10471975511965977;
  Float dih2  = -0.715584993317675; //mean = -41deg, std = 8deg
  Float std2  = 0.13962634015954636;
  Float corr = -0.25;
  Float weight = 0.5;
  core::BinormalTerm bt;
  bt.set_means(std::make_pair(dih1,dih2));
  bt.set_standard_deviations(std::make_pair(std1,std2));
  bt.set_correlation(corr);
  bt.set_weight(weight);

  //bond info
  Float distON = 2.96;
  Float kON = core::Harmonic::get_k_from_standard_deviation(0.11);

  //will expand to more bonds and residue types
  bond_ON_score_ = new core::HarmonicDistancePairScore(distON,kON);

  if (rs.size()>=3){
    for(size_t nr=0;nr<rs.size()-2;nr++){
      core::XYZ a1(get_atom(rs[nr],AT_C));
      core::XYZ a2(get_atom(rs[nr+1],AT_N));
      core::XYZ a3(get_atom(rs[nr+1],AT_CA));
      core::XYZ a4(get_atom(rs[nr+1],AT_C));
      core::XYZ a5(get_atom(rs[nr+2],AT_N));
      IMP_NEW(core::MultipleBinormalRestraint,
              mbr,(get_model(),
                   ParticleIndexQuad(a1,a2,a3,a4),
                   ParticleIndexQuad(a2,a3,a4,a5)));
      mbr->add_term(bt);
      dihedral_rs_.push_back(mbr);
    }
  }

  if (rs.size()>=5){
    for(size_t nr=0;nr<rs.size()-4;nr++){
      bonds_ON_.push_back(ParticleIndexPair(
                                            get_atom(rs[nr],AT_O).get_particle_index(),
                                            get_atom(rs[nr+4],AT_N).get_particle_index()));
    }
  }
}
Exemple #29
0
void final_snapshot::launch_with_estimator()
{
  while(true)
  {
    std::size_t steps_left = m_final_estimator_ptr->estimate();

    if(0 == steps_left)
      break;

    bool ok = m_advancer_ptr->advance(steps_left);
    if(!ok)
      break;
  }
  m_stream_printer_ptr->write_dataframe(get_model().current_configuration());
}
Exemple #30
0
Float HelixRestraint::unprotected_evaluate(DerivativeAccumulator *accum) const {
  Float score = 0.0;
  Model *m = get_model();
  for (IMP::Vector<IMP::PointerMember<
         core::MultipleBinormalRestraint> >::const_iterator td = dihedral_rs_.begin();
       td != dihedral_rs_.end(); ++td){
    score += (*td)->unprotected_evaluate(accum);
  }

  for (ParticleIndexPairs::const_iterator tb = bonds_ON_.begin();
       tb != bonds_ON_.end(); ++tb) {
    score += bond_ON_score_->evaluate_index(m, *tb, accum);
  }
  return score;
}