nblist_3body.h

Go to the documentation of this file.

/*
 * Copyright 2009-2020 The VOTCA Development Team (http://www.votca.org)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
 
#ifndef VOTCA_CSG_NBLIST_3BODY_H
#define VOTCA_CSG_NBLIST_3BODY_H
 
// Local VOTCA includes
#include "beadlist.h"
#include "beadtriple.h"
#include "exclusionlist.h"
#include "triplelist.h"
 
namespace votca {
namespace csg {
 
class NBList_3Body : public TripleList<Bead *, BeadTriple> {
 public:
  NBList_3Body();
  ~NBList_3Body() override;
 
  virtual void Generate(BeadList &list1, BeadList &list2, BeadList &list3,
                        bool do_exclusions = true);
  virtual void Generate(BeadList &list1, BeadList &list2,
                        bool do_exclusions = true) {
    Generate(list1, list2, list2, do_exclusions);
  };
  virtual void Generate(BeadList &list, bool do_exclusions = true) {
    Generate(list, list, list, do_exclusions);
  }
 
  void setCutoff(const double cutoff) { cutoff_ = cutoff; }
  double getCutoff() { return cutoff_; }
 
  template <typename T>
  void SetMatchFunction(
      T *object, bool (T::*fkt)(Bead *, Bead *, Bead *, const Eigen::Vector3d &,
                                const Eigen::Vector3d &,
                                const Eigen::Vector3d &, const double dist12,
                                const double dist13, const double dist23));
 
  void SetMatchFunction(bool (*fkt)(
      Bead *, Bead *, Bead *, const Eigen::Vector3d &, const Eigen::Vector3d &,
      const Eigen::Vector3d &, const double dist12, const double dist13,
      const double dist23));
 
  static bool match_always(Bead *, Bead *, Bead *, const Eigen::Vector3d &,
                           const Eigen::Vector3d &, const Eigen::Vector3d &,
                           const double, const double, const double) {
    return true;
  }
 
  template <typename triple_type>
  void setTripleType();
 
 protected:
  double cutoff_;
  bool do_exclusions_;
 
  template <typename triple_type>
  static BeadTriple *beadtriple_create_policy(Bead *bead1, Bead *bead2,
                                              Bead *bead3,
                                              const Eigen::Vector3d &r12,
                                              const Eigen::Vector3d &r13,
                                              const Eigen::Vector3d &r23) {
    return dynamic_cast<BeadTriple *>(
        new triple_type(bead1, bead2, bead3, r12, r13, r23));
  }
 
  using triple_creator_t = BeadTriple *(*)(Bead *, Bead *, Bead *,
                                           const Eigen::Vector3d &,
                                           const Eigen::Vector3d &,
                                           const Eigen::Vector3d &);
  triple_creator_t triple_creator_;
 
 protected:
  class Functor {
   public:
    Functor() = default;
    virtual bool operator()(Bead *, Bead *, Bead *, const Eigen::Vector3d &,
                            const Eigen::Vector3d &, const Eigen::Vector3d &,
                            const double dist12, const double dist13,
                            const double dist23) = 0;
    virtual ~Functor() = default;
  };
 
  template <typename T>
  class FunctorMember : public Functor {
   public:
    using fkt_t = bool (T::*)(Bead *, Bead *, Bead *, const Eigen::Vector3d &,
                              const Eigen::Vector3d &, const Eigen::Vector3d &,
                              const double, const double, const double);
 
    FunctorMember(T *cls, fkt_t fkt) : cls_(cls), fkt_(fkt) {}
 
    bool operator()(Bead *b1, Bead *b2, Bead *b3, const Eigen::Vector3d &r12,
                    const Eigen::Vector3d &r13, const Eigen::Vector3d &r23,
                    const double dist12, const double dist13,
                    const double dist23) override {
      return (cls_->*fkt_)(b1, b2, b3, r12, r13, r23, dist12, dist13, dist23);
    }
 
   private:
    T *cls_;
    fkt_t fkt_;
  };
 
  class FunctorNonMember : public Functor {
   public:
    using fkt_t = bool (*)(Bead *, Bead *, Bead *, const Eigen::Vector3d &,
                           const Eigen::Vector3d &, const Eigen::Vector3d &,
                           const double, const double, const double);
    FunctorNonMember(fkt_t fkt) : fkt_(fkt) {}
 
    bool operator()(Bead *b1, Bead *b2, Bead *b3, const Eigen::Vector3d &r12,
                    const Eigen::Vector3d &r13, const Eigen::Vector3d &r23,
                    const double dist12, const double dist13,
                    const double dist23) override {
      return (*fkt_)(b1, b2, b3, r12, r13, r23, dist12, dist13, dist23);
    }
 
   private:
    fkt_t fkt_;
  };
 
  std::unique_ptr<Functor> match_function_;
};
 
template <typename triple_type>
void NBList_3Body::setTripleType() {
  triple_creator_ = NBList_3Body::beadtriple_create_policy<triple_type>;
}
 
template <typename T>
inline void NBList_3Body::SetMatchFunction(
    T *object, bool (T::*fkt)(Bead *, Bead *, Bead *, const Eigen::Vector3d &,
                              const Eigen::Vector3d &, const Eigen::Vector3d &,
                              const double dist12, const double dist13,
                              const double dist23)) {
 
  match_function_.reset(new FunctorMember<T>(object, fkt));
}
 
inline void NBList_3Body::SetMatchFunction(bool (*fkt)(
    Bead *, Bead *, Bead *, const Eigen::Vector3d &, const Eigen::Vector3d &,
    const Eigen::Vector3d &, const double dist12, const double dist13,
    const double dist23)) {
  match_function_.reset(new FunctorNonMember(fkt));
}
 
}  // namespace csg
}  // namespace votca
 
#endif  // VOTCA_CSG_NBLIST_3BODY_H