ConsecutivePairContainer.h

Go to the documentation of this file.

/**
 *  \file IMP/container/ConsecutivePairContainer.h
 *  \brief Return all pairs from a SingletonContainer
 *
 *  Copyright 2007-2022 IMP Inventors. All rights reserved.
 */

#ifndef IMPCONTAINER_CONSECUTIVE_PAIR_CONTAINER_H
#define IMPCONTAINER_CONSECUTIVE_PAIR_CONTAINER_H

#include <IMP/container/container_config.h>
#include <IMP/generic.h>
#include <IMP/PairContainer.h>
#include <IMP/PairPredicate.h>
#include <IMP/SingletonContainer.h>
#include <IMP/container/ListPairContainer.h>
#include <boost/unordered_map.hpp>
#include <IMP/pair_macros.h>

IMPCONTAINER_BEGIN_NAMESPACE

//! A container which contains all consecutive particle pairs from an input list
/** If it is assumed that each particle is in at most one such container,
    then ExclusiveConsecutivePairContainer should be used instead,
    since it is faster when doing certain computations.

    Also see ConsecutivePairFilter.
*/
class IMPCONTAINEREXPORT ConsecutivePairContainer : public PairContainer {
  friend class ConsecutivePairFilter;
  const ParticleIndexes ps_;
  IntKey key_;
  /**
     add the key of this container as an attribute to all particles
     if there might be overlaps - create a different key for each instance
  */
  void init();

  bool get_contains(const ParticleIndexPair &p) const {
    if (!get_model()->get_has_attribute(key_, std::get<0>(p))) return false;
    int ia = get_model()->get_attribute(key_, std::get<0>(p));
    if (!get_model()->get_has_attribute(key_, std::get<1>(p))) return false;
    int ib = get_model()->get_attribute(key_, std::get<1>(p));
    return std::abs(ia - ib) == 1;
  }

 protected:
  virtual std::size_t do_get_contents_hash() const override { return 0; }

 public:
  //! apply to each item in container
  template <class F>
  void apply_generic(F *f) const {
    for (unsigned int i = 1; i < ps_.size(); ++i) {
      f->apply_index(get_model(),
                     ParticleIndexPair(ps_[i - 1], ps_[i]));
    }
  }

  ConsecutivePairContainer(Model *m, const ParticleIndexes &ps,
                           std::string name = "ConsecutivePairContainer%1%");

  virtual ParticleIndexPairs get_indexes() const override;
  virtual ParticleIndexPairs get_range_indexes() const override;
  virtual ModelObjectsTemp do_get_inputs() const override;
  virtual ParticleIndexes get_all_possible_indexes() const override;
  IMP_PAIR_CONTAINER_METHODS(ConsecutivePairContainer);
  IMP_OBJECT_METHODS(ConsecutivePairContainer);
};

IMP_OBJECTS(ConsecutivePairContainer, ConsecutivePairContainers);

/** Check for whether the pair is a member of a specific
    ConsecutivePairContainer. */
class IMPCONTAINEREXPORT ConsecutivePairFilter : public PairPredicate {
  PointerMember<ConsecutivePairContainer> cpc_;

 public:
  /** @param cpc the consecutive pair container that stores
                 filtered pairs
  */
  ConsecutivePairFilter(ConsecutivePairContainer *cpc);

  virtual int get_value_index(Model *,
                              const ParticleIndexPair &pip) const
      override {
    return cpc_->get_contains(pip);
  }
  virtual ModelObjectsTemp do_get_inputs(
      Model *m, const ParticleIndexes &pi) const override {
    ModelObjectsTemp ret;
    ret += IMP::get_particles(m, pi);
    return ret;
  }
  IMP_PAIR_PREDICATE_METHODS(ConsecutivePairFilter);
  IMP_OBJECT_METHODS(ConsecutivePairFilter);
};

/** This is an ConsecutivePairContainer where each particle can only be on
    one ExclusiveConsecutivePairContainer. The exclusivity makes the code
    more efficient and allows one to use the ExclusiveConsecutivePairFilter,
    which is way more efficient than using an InContainerPairFilter
    with a ConsecutivePairContainer.*/
class IMPCONTAINEREXPORT ExclusiveConsecutivePairContainer
    : public PairContainer {
  friend class ExclusiveConsecutivePairFilter;
  const ParticleIndexes ps_;
  static IntKey get_exclusive_key() {
    static IntKey k("exclusive consecutive numbering");
    return k;
  }
  static ObjectKey get_exclusive_object_key() {
    static ObjectKey k("exclusive consecutive container");
    return k;
  }
  static bool get_contains(Model *m,
                           const ParticleIndexPair &pp) {
    ObjectKey ok =
        ExclusiveConsecutivePairContainer::get_exclusive_object_key();
    bool has_eok_0 = m->get_has_attribute(ok, std::get<0>(pp));
    bool has_eok_1= m->get_has_attribute(ok, std::get<1>(pp));
    if ( !has_eok_0 || !has_eok_1 )
      return false;
    if (m->get_attribute(ok, std::get<0>(pp))
        != m->get_attribute(ok, std::get<1>(pp))) {
      return false;
    }
    IntKey k = ExclusiveConsecutivePairContainer::get_exclusive_key();
    int ia = m->get_attribute(k, std::get<0>(pp));
    int ib = m->get_attribute(k, std::get<1>(pp));
    return std::abs(ia - ib) == 1;
  }
  void init();

 protected:
  virtual std::size_t do_get_contents_hash() const override { return 0; }

  /**
      Called by Object destructor - removes all keys associated with
      the exclusive consecutive pair container, so it can be now added to
      another exclusive consecutive pair container
  */
  virtual void do_destroy() override;


 public:
  //! apply to each item in container
  template <class F>
  void apply_generic(F *f) const {
    for (unsigned int i = 1; i < ps_.size(); ++i) {
      f->apply_index(get_model(),
                     ParticleIndexPair(ps_[i - 1], ps_[i]));
    }
  }

  ExclusiveConsecutivePairContainer(Model *m, const ParticleIndexes &ps,
                                    std::string name =
                                        "ExclusiveConsecutivePairContainer%1%");

  virtual ParticleIndexPairs get_indexes() const override;
  virtual ParticleIndexPairs get_range_indexes() const override;
  virtual ModelObjectsTemp do_get_inputs() const override;
  virtual ParticleIndexes get_all_possible_indexes() const override;
  IMP_PAIR_CONTAINER_METHODS(ExclusiveConsecutivePairContainer);
  IMP_OBJECT_METHODS(ExclusiveConsecutivePairContainer);
};

/** Check for whether the pair is a member of any
    ExclusiveConsecutivePairContainer. */
class IMPCONTAINEREXPORT ExclusiveConsecutivePairFilter : public PairPredicate {
 public:
  ExclusiveConsecutivePairFilter()
      : PairPredicate("ExclusiveConsecutivePairFilter %1%") {}

  virtual int get_value_index(Model *m,
                              const ParticleIndexPair &pip) const
      override {
    return ExclusiveConsecutivePairContainer::get_contains(m, pip);
  }
  virtual ModelObjectsTemp do_get_inputs(
      Model *m, const ParticleIndexes &pi) const override {
    ModelObjectsTemp ret;
    ret += IMP::get_particles(m, pi);
    return ret;
  }
  IMP_PAIR_PREDICATE_METHODS(ExclusiveConsecutivePairFilter);
  IMP_OBJECT_METHODS(ExclusiveConsecutivePairFilter);
};

IMPCONTAINER_END_NAMESPACE

#endif /* IMPCONTAINER_CONSECUTIVE_PAIR_CONTAINER_H */