bead.h

Go to the documentation of this file.

/*
 * Copyright 2009-2021 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_BEAD_H
#define VOTCA_CSG_BEAD_H
#pragma once
 
// Standard includes
#include <cassert>
#include <string>
 
// VOTCA includes
#include <votca/tools/property.h>
#include <votca/tools/types.h>
 
// Local VOTCA includes
#include "basebead.h"
 
namespace votca {
namespace csg {
 
class Topology;
class Molecule;
 
class Bead : public BaseBead {
 public:
  ~Bead() override = default;
 
  const Index &getResnr() const { return residue_number_; }
 
  virtual const double &getQ() const { return charge_; }
 
  virtual void setQ(const double &q) { charge_ = q; }
 
  enum Symmetry { spherical = 1, ellipsoidal = 3 };
  Symmetry getSymmetry() const { return symmetry_; }
 
  void setVel(const Eigen::Vector3d &r);
 
  const Eigen::Vector3d &getVel() const;
 
  void setU(const Eigen::Vector3d &u);
 
  const Eigen::Vector3d &getU() const;
 
  void setV(const Eigen::Vector3d &v);
 
  const Eigen::Vector3d &getV() const;
 
  void setW(const Eigen::Vector3d &w);
 
  const Eigen::Vector3d &getW() const;
 
  Eigen::Vector3d &Vel() {
    assert(bead_velocity_set_ &&
           "Cannot access velocity, it has not been set.");
    return velocity_;
  }
 
  Eigen::Vector3d &U() {
    assert(bU_ && "Cannot access bead orientation u, has not been set.");
    return u_;
  }
 
  Eigen::Vector3d &V() {
    assert(bV_ && "Cannot access bead orientation v, has not been set.");
    return v_;
  }
 
  Eigen::Vector3d &W() {
    assert(bW_ && "Cannot access bead orientation w, has not been set.");
    return w_;
  }
 
  Eigen::Vector3d &F() {
    assert(bead_force_set_ && "Cannot access bead force, has not been set.");
    return bead_force_;
  }
 
  void setF(const Eigen::Vector3d &bead_force);
 
  const Eigen::Vector3d &getF() const;
 
  bool HasVel() const noexcept { return bead_velocity_set_; }
 
  bool HasF() const noexcept { return bead_force_set_; }
 
  bool HasU() const noexcept { return bU_; }
 
  bool HasV() const noexcept { return bV_; }
 
  bool HasW() const noexcept { return bW_; }
 
  void HasVel(bool b);
 
  void HasF(bool b);
 
  void HasU(bool b);
 
  void HasV(bool b);
 
  void HasW(bool b);
 
  const std::vector<Index> &ParentBeads() { return parent_beads_; };
 
  void ClearParentBeads() { parent_beads_.clear(); }
 
  void AddParentBead(Index parent_bead_id) {
    parent_beads_.push_back(parent_bead_id);
  }
 
 protected:
  std::vector<Index> parent_beads_;
 
  Symmetry symmetry_;
  double charge_;
 
  Index residue_number_;
 
  Eigen::Vector3d velocity_, bead_force_, u_, v_, w_;
 
  bool bead_velocity_set_;
  bool bU_;
  bool bV_;
  bool bW_;
  bool bead_force_set_;
 
  Bead(Index id, std::string type, Symmetry symmetry, std::string name,
       Index resnr, double m, double q)
      : symmetry_(symmetry), charge_(q), residue_number_(resnr) {
    setId(id);
    setType(type);
    setName(name);
    setMass(m);
    bead_position_set_ = false;
    bead_velocity_set_ = false;
    bU_ = false;
    bV_ = false;
    bW_ = false;
    bead_force_set_ = false;
  }
 
  friend class Topology;
  friend class Molecule;
};
 
inline void Bead::setVel(const Eigen::Vector3d &r) {
  bead_velocity_set_ = true;
  velocity_ = r;
}
 
inline const Eigen::Vector3d &Bead::getVel() const {
  assert(bead_velocity_set_ &&
         "Cannot access bead velocity, has not been set.");
  return velocity_;
}
 
inline void Bead::setU(const Eigen::Vector3d &u) {
  bU_ = true;
  u_ = u;
}
 
inline const Eigen::Vector3d &Bead::getU() const {
  assert(bU_ && "Cannot access bead orientation u, has not been set.");
  return u_;
}
 
inline void Bead::setV(const Eigen::Vector3d &v) {
  bV_ = true;
  v_ = v;
}
 
inline const Eigen::Vector3d &Bead::getV() const {
  assert(bV_);
  return v_;
}
 
inline void Bead::setW(const Eigen::Vector3d &w) {
  bW_ = true;
  w_ = w;
}
 
inline const Eigen::Vector3d &Bead::getW() const {
  assert(bW_ && "Cannot access bead orientation w, has not been set.");
  return w_;
}
 
inline void Bead::setF(const Eigen::Vector3d &bead_force) {
  bead_force_set_ = true;
  bead_force_ = bead_force;
}
 
inline const Eigen::Vector3d &Bead::getF() const {
  assert(bead_force_set_ && "Cannot access bead force, has not been set.");
  return bead_force_;
}
 
inline void Bead::HasVel(bool b) { bead_velocity_set_ = b; }
 
inline void Bead::HasF(bool b) { bead_force_set_ = b; }
 
inline void Bead::HasU(bool b) { bU_ = b; }
 
inline void Bead::HasV(bool b) { bV_ = b; }
 
inline void Bead::HasW(bool b) { bW_ = b; }
}  // namespace csg
}  // namespace votca
 
#endif  // VOTCA_CSG_BEAD_H