OrthoBoxExternal.cpp

/*
* 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 "OrthoBoxExternal.h"

#include <iostream>

namespace Simp
{

   using namespace Util;

   /* 
   * Constructor.
   */
   OrthoBoxExternal::OrthoBoxExternal() 
    : indConfine_(3),
      boundaryPtr_(0),
      nAtomType_(0),
      isInitialized_(false)
   {  setClassName("OrthoBoxExternal"); }
   
   /* 
   * Copy constructor.
   */
   OrthoBoxExternal::OrthoBoxExternal(const OrthoBoxExternal& other)
    : indConfine_(other.indConfine_),
      epsilon_(other.epsilon_),
      sigma_(other.sigma_),
      sigmaCb_(other.sigmaCb_),
      cutoff_(other.cutoff_),
      coeff_(other.coeff_),
      boundaryPtr_(other.boundaryPtr_),
      nAtomType_(other.nAtomType_),
      isInitialized_(other.isInitialized_)
   {}
   
   /* 
   * Assignment operator.
   */
   OrthoBoxExternal& OrthoBoxExternal::operator = (const OrthoBoxExternal& other)
   {
      indConfine_    = other.indConfine_;
      boundaryPtr_   = other.boundaryPtr_;
      nAtomType_     = other.nAtomType_;
      isInitialized_ = other.isInitialized_;
      epsilon_       = other.epsilon_;
      sigma_         = other.sigma_;
      sigmaCb_       = other.sigmaCb_;
      cutoff_        = other.cutoff_;
      coeff_         = other.coeff_;
      return *this;
   }

   /* 
   * Set nAtomType
   */
   void OrthoBoxExternal::setNAtomType(int nAtomType) 
   {  
      if (nAtomType <= 0) {
         UTIL_THROW("nAtomType <= 0");
      }
      if (nAtomType > MaxAtomType) {
         UTIL_THROW("nAtomType > OrthoBoxExternal::MaxAtomType");
      }
      nAtomType_ = nAtomType;
   }

   /* 
   * Set pointer to the Boundary.
   */
   void OrthoBoxExternal::setBoundary(Boundary &boundary)
   {  boundaryPtr_ = &boundary; }
   
   void OrthoBoxExternal::setExternalParameter(double externalParameter)
   {
      // Preconditions
      if (!isInitialized_) {
         UTIL_THROW("OrthoBoxExternal potential is not initialized");
      }

      epsilon_ = externalParameter;
   }

   /* 
   * Read potential parameters from file.
   */
   void OrthoBoxExternal::readParameters(std::istream &in) 
   {
      if (nAtomType_ == 0) {
         UTIL_THROW("nAtomType must be set before readParam");
      }
      if (!boundaryPtr_) {
         UTIL_THROW("Boundary must be set before readParam");
      }
   
      // Read parameters
      read<int>(in, "indexConfinement", indConfine_);
      if (indConfine_ < 0 || indConfine_ > Dimension) {
         UTIL_THROW("Invalid index for confinement directions.");
      }
      read<double>(in, "epsilon", epsilon_);
      read<double>(in, "sigma", sigma_);
      read<double>(in, "cutoff", cutoff_);

      // Initialize dependent variables (particle number density = 0.7)
      sigmaCb_ = sigma_ * sigma_ * sigma_;
      coeff_   = 4.0 * epsilon_ * acos(-1.0) / 45.0 * 0.7 * sigmaCb_;

      isInitialized_ = true;
   }

   /*
   * Load internal state from an archive.
   */
   void OrthoBoxExternal::loadParameters(Serializable::IArchive &ar)
   {
      ar >> nAtomType_; 
      if (nAtomType_ <= 0) {
         UTIL_THROW( "nAtomType must be positive");
      }
      if (!boundaryPtr_) {
         UTIL_THROW("Boundary must be set before readParam");
      }
      loadParameter<int>(ar, "indexConfinement", indConfine_);
      if (indConfine_ < 0 || indConfine_ > Dimension) {
         UTIL_THROW("Invalid index for confinement directions.");
      }
      loadParameter<double>(ar, "epsilon", epsilon_);
      loadParameter<double>(ar, "sigma", sigma_);
      loadParameter<double>(ar, "cutoff", cutoff_);
      ar >> sigmaCb_;
      ar >> coeff_;
      isInitialized_ = true;
   }

   /*
   * Save internal state to an archive.
   */
   void OrthoBoxExternal::save(Serializable::OArchive &ar)
   {
      ar << nAtomType_;
      ar << indConfine_;
      ar << epsilon_;
      ar << sigma_;
      ar << cutoff_;
      ar << sigmaCb_;
      ar << coeff_;
   }

   /*
   * Set a potential energy parameter, identified by a string.
   */
   void OrthoBoxExternal::set(std::string name, double value)
   {
      if (name == "epsilon") {
         epsilon_ = value;
      } else
      if (name == "sigma") {
         sigma_ = value;
      } else
      if (name == "cutoff") {
         cutoff_ = value;
      } else {
         UTIL_THROW("Unrecognized parameter name");
      }
   }

   /*
   * Get a parameter value, identified by a string.
   */
   double OrthoBoxExternal::get(std::string name) const
   {
      double value = 0.0;
      if (name == "epsilon") {
         value = epsilon_;
      } else
      if (name == "sigma") {
         value = sigma_;
      } else
      if (name == "cutoff") {
         value = cutoff_;
      } else {
         UTIL_THROW("Unrecognized parameter name");
      }
      return value;
   }

   double OrthoBoxExternal::externalParameter() const
   {
     return epsilon_;
   }

   std::string OrthoBoxExternal::className() const
   {  return std::string("OrthoBoxExternal"); }
 

}