HarmonicL0Bond.h

#ifndef SIMP_HARMONIC_L0_BOND_H
#define SIMP_HARMONIC_L0_BOND_H

/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <util/global.h>

#include <util/param/ParamComposite.h>  // base class
#include <util/random/Random.h>           // Util namespace

#include <cmath>

namespace Simp
{

   using namespace Util;

   class HarmonicL0Bond : public ParamComposite 
   {
   
   public:

      HarmonicL0Bond();
   
      HarmonicL0Bond(const HarmonicL0Bond& other);
   
      // Default destructor.
 
      HarmonicL0Bond& operator = (const HarmonicL0Bond& other);
  
      void setNBondType(int nBondType);

      void readParameters(std::istream &in);

      virtual void loadParameters(Serializable::IArchive &ar);

      virtual void save(Serializable::OArchive &ar);

      double energy(double rSq, int type) const;
   
      double forceOverR(double rSq, int type) const;
   
      double randomBondLength(Random *random, double beta, int type) const;
   
      void set(std::string name, int type, double value);

      double get(std::string name, int type) const;

      double kappa(int type) const;

   private:
   
      static const int MaxNBondType = 2;
   
      double kappa_[MaxNBondType];  
      int    nBondType_;            

   };
   
   // Inline method definitions

   /*
    * Return bond spring constant
    */
   inline double HarmonicL0Bond::kappa(int type) const
   {
      assert(type >= 0);
      assert(type < nBondType_);
      return kappa_[type];
   }
   
   /* 
   * Return interaction energy for one bond
   */
   inline double HarmonicL0Bond::energy(double rSq, int type) const
   {  return 0.5*kappa_[type]*rSq; }

   /* 
   * Return force / distance for one bond, for use in MD
   */
   inline 
   double HarmonicL0Bond::forceOverR(double rSq, int type) const
   {  return -kappa_[type]; }
   
} 
#endif