Diffusion lammps (efficient_neuronet) Browse

colvarvalue.h
d7fa3ba7185fefficient_neuronet

colvarvalue.h
View Options

			// -- c++ --

			#ifndef COLVARVALUE_H
			#define COLVARVALUE_H

			#include "colvarmodule.h"
			#include "colvartypes.h"


			/// \brief Value of a collective variable: this is a metatype which
			/// can be set at runtime. By default it is set to be a scalar
			/// number, and can be treated as such in all operations (this is
			/// done by most \link cvc \endlink implementations).
			///
			/// \link colvarvalue \endlink allows \link colvar \endlink to be
			/// treat different data types. By default, a \link colvarvalue
			/// \endlink variable is a scalar number. To use it as
			/// another type, declare and initialize it as
			/// \code colvarvalue x(colvarvalue::type_xxx)\endcode, use \link x.type
			/// (colvarvalue::type_xxx) \endlink at a later stage, or if unset,
			/// assign the type with \code x = y; \endcode, provided y is correctly set.
			///
			/// All operators (either unary or binary) on a \link
			/// colvarvalue \endlink object performs one or more checks on the
			/// \link Type \endlink, except when reading from a stream, when there is no way to
			/// detect the \link Type \endlink. To use \code is >> x; \endcode x \b MUST
			/// already have a type correcly set up for properly parsing the
			/// stream. No problem of course with the output streams: \code os << x; \endcode
			///
			/// \em Note \em on \em performance: to avoid type checks in a long array of \link
			/// colvarvalue \endlink objects, use one of the existing "_opt" functions or implement a new one


			class colvarvalue {

			public:

			/// \brief Possible types of value
			///
			/// These three cover most possibilities of data type one can
			/// devise. If you need to implement a new colvar with a very
			/// complex data type, it's better to put an allocatable class here
			enum Type {
			/// Undefined type
			type_notset,
			/// Scalar number, implemented as \link colvarmodule::real \endlink (default)
			type_scalar,
			/// 3-dimensional vector, implemented as \link colvarmodule::rvector \endlink
			type_3vector,
			/// 3-dimensional unit vector, implemented as \link colvarmodule::rvector \endlink
			type_unit3vector,
			/// 3-dimensional vector that is a derivative of a unitvector
			type_unit3vectorderiv,
			/// 4-dimensional unit vector representing a rotation, implemented as \link colvarmodule::quaternion \endlink
			type_quaternion,
			/// 4-dimensional vector that is a derivative of a quaternion
			type_quaternionderiv,
			/// vector (arbitrary dimension)
			type_vector,
			/// Needed to iterate through enum
			type_all
			};

			/// Current type of this colvarvalue object
			Type value_type;

			/// \brief Real data member
			cvm::real real_value;

			/// \brief 3-dimensional vector data member
			cvm::rvector rvector_value;

			/// \brief Quaternion data member
			cvm::quaternion quaternion_value;

			/// \brief Generic vector data member
			cvm::vector1d<cvm::real> vector1d_value;

			/// \brief If \link vector1d_value \endlink is a concatenation of colvarvalues,
			/// keep track of the individual types
			std::vector<Type> elem_types;

			/// \brief If \link vector1d_value \endlink is a concatenation of colvarvalues,
			/// these mark the initial components of each colvarvalue
			std::vector<int> elem_indices;

			/// \brief If \link vector1d_value \endlink is a concatenation of colvarvalues,
			/// these mark how many components for each colvarvalue
			std::vector<int> elem_sizes;

			/// \brief Whether or not the type check is enforced
			static inline bool type_checking()
			{
			return true;
			}

			/// Runtime description of value types
			static std::string const type_desc(Type t);

			/// User keywords for specifying value types in the configuration
			static std::string const type_keyword(Type t);

			/// Number of degrees of freedom for each supported type
			static size_t num_df(Type t);

			/// Number of dimensions for each supported type (used to allocate vector1d_value)
			static size_t num_dimensions(Type t);

			/// Number of dimensions of this variable
			size_t size() const;

			/// \brief Default constructor: this class defaults to a scalar
			/// number and always behaves like it unless you change its type
			inline colvarvalue()
			: value_type(type_scalar), real_value(0.0)
			{}

			/// Constructor from a type specification
			inline colvarvalue(Type const &vti)
			: value_type(vti)
			{
			reset();
			}

			/// Copy constructor from real base type
			inline colvarvalue(cvm::real const &x)
			: value_type(type_scalar), real_value(x)
			{}

			/// \brief Copy constructor from rvector base type (Note: this sets
			/// automatically a type \link type_3vector \endlink , if you want a
			/// \link type_unit3vector \endlink you must set it explicitly)
			inline colvarvalue(cvm::rvector const &v)
			: value_type(type_3vector), rvector_value(v)
			{}

			/// \brief Copy constructor from rvector base type (additional
			/// argument to make possible to choose a \link type_unit3vector
			/// \endlink
			inline colvarvalue(cvm::rvector const &v, Type const &vti)
			: value_type(vti), rvector_value(v)
			{}

			/// \brief Copy constructor from quaternion base type
			inline colvarvalue(cvm::quaternion const &q)
			: value_type(type_quaternion), quaternion_value(q)
			{}

			/// Copy constructor from another \link colvarvalue \endlink
			colvarvalue(colvarvalue const &x);

			/// Copy constructor from vector1d base type
			colvarvalue(cvm::vector1d<cvm::real> const &v, Type const &vti);


			/// Set to the null value for the data type currently defined
			void reset();

			/// \brief If the variable has constraints (e.g. unitvector or
			/// quaternion), transform it to satisfy them; this function needs
			/// to be called only when the \link colvarvalue \endlink
			/// is calculated outside of \link cvc \endlink objects
			void apply_constraints();

			/// Get the current type
			inline Type type() const
			{
			return value_type;
			}

			/// Set the type explicitly
			inline void type(Type const &vti)
			{
			if (vti != value_type) {
			// reset the value based on the previous type
			reset();
			if ((value_type == type_vector) && (vti != type_vector)) {
			vector1d_value.resize(0);
			}
			value_type = vti;
			}
			}

			/// Set the type after another \link colvarvalue \endlink
			inline void type(colvarvalue const &x)
			{
			if (x.type() != value_type) {
			// reset the value based on the previous type
			reset();
			if (value_type == type_vector) {
			vector1d_value.resize(0);
			}
			value_type = x.type();
			}

			if (x.type() == type_vector) {
			vector1d_value.resize(x.vector1d_value.size());
			}
			}

			/// Make the type a derivative of the original type
			/// (so that its constraints do not apply)
			inline void is_derivative();

			/// Square norm of this colvarvalue
			cvm::real norm2() const;

			/// Norm of this colvarvalue
			inline cvm::real norm() const
			{
			return std::sqrt(this->norm2());
			}

			/// \brief Return the value whose scalar product with this value is
			/// 1
			inline colvarvalue inverse() const;

			/// Square distance between this \link colvarvalue \endlink and another
			cvm::real dist2(colvarvalue const &x2) const;

			/// Derivative with respect to this \link colvarvalue \endlink of the square distance
			colvarvalue dist2_grad(colvarvalue const &x2) const;

			/// Assignment operator (type of x is checked)
			colvarvalue & operator = (colvarvalue const &x);

			void operator += (colvarvalue const &x);
			void operator -= (colvarvalue const &x);
			void operator *= (cvm::real const &a);
			void operator /= (cvm::real const &a);

			// Binary operators (return values)
			friend colvarvalue operator + (colvarvalue const &x1, colvarvalue const &x2);
			friend colvarvalue operator - (colvarvalue const &x1, colvarvalue const &x2);
			friend colvarvalue operator * (colvarvalue const &x, cvm::real const &a);
			friend colvarvalue operator * (cvm::real const &a, colvarvalue const &x);
			friend colvarvalue operator / (colvarvalue const &x, cvm::real const &a);

			/// Inner product
			friend cvm::real operator * (colvarvalue const &x1, colvarvalue const &x2);

			// Cast to scalar
			inline operator cvm::real() const
			{
			if (value_type != type_scalar) {
			cvm::error("Error: trying to use a variable of type \""+
			type_desc(value_type)+"\" as one of type \""+
			type_desc(type_scalar)+"\".\n");
			}
			return real_value;
			}

			// Cast to 3-vector
			inline operator cvm::rvector() const
			{
			if ((value_type != type_3vector) &&
			(value_type != type_unit3vector) &&
			(value_type != type_unit3vectorderiv)) {
			cvm::error("Error: trying to use a variable of type \""+
			type_desc(value_type)+"\" as one of type \""+
			type_desc(type_3vector)+"\".\n");
			}
			return rvector_value;
			}

			// Cast to quaternion
			inline operator cvm::quaternion() const
			{
			if ((value_type != type_quaternion) &&
			(value_type != type_quaternionderiv)) {
			cvm::error("Error: trying to use a variable of type \""+
			type_desc(value_type)+"\" as one of type \""+
			type_desc(type_quaternion)+"\".\n");
			}
			return quaternion_value;
			}

			// Create a n-dimensional vector from one of the basic types, or return the existing vector
			cvm::vector1d<cvm::real> const as_vector() const;


			/// Whether this variable is a real number
			inline bool is_scalar() const
			{
			return (value_type == type_scalar);
			}


			/// Add an element to the vector (requires that type_vector is already set).
			/// This is only needed to use this object as a vector of "complex" colvar values.
			/// To use it instead as a plain n-dimensional vector, access vector1d_value directly.
			void add_elem(colvarvalue const &x);

			/// Get a single colvarvalue out of elements of the vector
			colvarvalue const get_elem(int const i_begin, int const i_end, Type const vt) const;

			/// Set elements of the vector from a single colvarvalue
			void set_elem(int const i_begin, int const i_end, colvarvalue const &x);

			/// Get a single colvarvalue out of elements of the vector
			colvarvalue const get_elem(int const icv) const;

			/// Set elements of the vector from a single colvarvalue
			void set_elem(int const icv, colvarvalue const &x);

			/// Get a scalar number out of an element of the vector
			inline cvm::real operator [] (int const i) const
			{
			if (vector1d_value.size() > 0) {
			return vector1d_value[i];
			} else {
			cvm::error("Error: trying to use as a vector a variable that is not initialized as such.\n");
			return 0.0;
			}
			}

			/// Use an element of the vector as a scalar number
			inline cvm::real & operator [] (int const i)
			{
			if (vector1d_value.size() > 0) {
			return vector1d_value[i];
			} else {
			cvm::error("Error: trying to use as a vector a variable that is not initialized as such.\n");
			real_value = 0.0;
			return real_value;
			}
			}


			/// Ensure that the two types are the same within a binary operator
			int static check_types(colvarvalue const &x1, colvarvalue const &x2);

			/// Ensure that the two types are the same within an assignment, or that the left side is type_notset
			int static check_types_assign(Type const &vt1, Type const &vt2);

			/// Undefined operation
			void undef_op() const;


			/// \brief Formatted output operator
			friend std::ostream & operator << (std::ostream &os, colvarvalue const &q);

			/// \brief Formatted input operator
			friend std::istream & operator >> (std::istream &is, colvarvalue &q);

			/// Give the number of characters required to output this
			/// colvarvalue, given the current type assigned and the number of
			/// characters for a real number
			size_t output_width(size_t const &real_width) const;

			/// Formats value as a script-friendly string (space separated list)
			std::string to_simple_string() const;

			/// Parses value from a script-friendly string (space separated list)
			int from_simple_string(std::string const &s);


			// optimized routines for operations on arrays of colvar values;
			// xv and result are assumed to have the same number of elements

			/// \brief Optimized routine for the inner product of one collective
			/// variable with an array
			void static inner_opt(colvarvalue const &x,
			std::vector<colvarvalue>::iterator &xv,
			std::vector<colvarvalue>::iterator const &xv_end,
			std::vector<cvm::real>::iterator &result);

			/// \brief Optimized routine for the inner product of one collective
			/// variable with an array
			void static inner_opt(colvarvalue const &x,
			std::list<colvarvalue>::iterator &xv,
			std::list<colvarvalue>::iterator const &xv_end,
			std::vector<cvm::real>::iterator &result);

			/// \brief Optimized routine for the second order Legendre
			/// polynomial, (3cos^2(w)-1)/2, of one collective variable with an
			/// array
			void static p2leg_opt(colvarvalue const &x,
			std::vector<colvarvalue>::iterator &xv,
			std::vector<colvarvalue>::iterator const &xv_end,
			std::vector<cvm::real>::iterator &result);

			/// \brief Optimized routine for the second order Legendre
			/// polynomial of one collective variable with an array
			void static p2leg_opt(colvarvalue const &x,
			std::list<colvarvalue>::iterator &xv,
			std::list<colvarvalue>::iterator const &xv_end,
			std::vector<cvm::real>::iterator &result);

			};



			inline std::string const colvarvalue::type_desc(Type t)
			{
			switch (t) {
			case colvarvalue::type_scalar:
			return "scalar number"; break;
			case colvarvalue::type_3vector:
			return "3-dimensional vector"; break;
			case colvarvalue::type_unit3vector:
			return "3-dimensional unit vector"; break;
			case colvarvalue::type_unit3vectorderiv:
			return "derivative of a 3-dimensional unit vector"; break;
			case colvarvalue::type_quaternion:
			return "4-dimensional unit quaternion"; break;
			case colvarvalue::type_quaternionderiv:
			return "4-dimensional tangent vector"; break;
			case colvarvalue::type_vector:
			return "n-dimensional vector"; break;
			case colvarvalue::type_notset:
			// fallthrough
			default:
			return "not set"; break;
			}
			}


			inline std::string const colvarvalue::type_keyword(Type t)
			{
			switch (t) {
			case colvarvalue::type_notset:
			default:
			return "not_set"; break;
			case colvarvalue::type_scalar:
			return "scalar"; break;
			case colvarvalue::type_3vector:
			return "vector3"; break;
			case colvarvalue::type_unit3vector:
			return "unit_vector3"; break;
			case colvarvalue::type_unit3vectorderiv:
			return ""; break;
			case colvarvalue::type_quaternion:
			return "unit_quaternion"; break;
			case colvarvalue::type_quaternionderiv:
			return ""; break;
			case colvarvalue::type_vector:
			return "vector"; break;
			}
			}


			inline size_t colvarvalue::num_df(Type t)
			{
			switch (t) {
			case colvarvalue::type_notset:
			default:
			return 0; break;
			case colvarvalue::type_scalar:
			return 1; break;
			case colvarvalue::type_3vector:
			return 3; break;
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			return 2; break;
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			return 3; break;
			case colvarvalue::type_vector:
			// the size of a vector is unknown without its object
			return 0; break;
			}
			}


			inline size_t colvarvalue::num_dimensions(Type t)
			{
			switch (t) {
			case colvarvalue::type_notset:
			default:
			return 0; break;
			case colvarvalue::type_scalar:
			return 1; break;
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			return 3; break;
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			return 4; break;
			case colvarvalue::type_vector:
			// the size of a vector is unknown without its object
			return 0; break;
			}
			}


			inline size_t colvarvalue::size() const
			{
			switch (value_type) {
			case colvarvalue::type_notset:
			default:
			return 0; break;
			case colvarvalue::type_scalar:
			return 1; break;
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			return 3; break;
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			return 4; break;
			case colvarvalue::type_vector:
			return vector1d_value.size(); break;
			}
			}


			inline colvarvalue::colvarvalue(colvarvalue const &x)
			: value_type(x.type())
			{
			switch (x.type()) {
			case type_scalar:
			real_value = x.real_value;
			break;
			case type_3vector:
			case type_unit3vector:
			case type_unit3vectorderiv:
			rvector_value = x.rvector_value;
			break;
			case type_quaternion:
			case type_quaternionderiv:
			quaternion_value = x.quaternion_value;
			break;
			case type_vector:
			vector1d_value = x.vector1d_value;
			elem_types = x.elem_types;
			elem_indices = x.elem_indices;
			elem_sizes = x.elem_sizes;
			case type_notset:
			default:
			break;
			}
			}

			inline colvarvalue::colvarvalue(cvm::vector1d<cvm::real> const &v, Type const &vti)
			{
			if ((vti != type_vector) && (v.size() != num_dimensions(vti))) {
			cvm::error("Error: trying to initialize a variable of type \""+type_desc(vti)+
			"\" using a vector of size "+cvm::to_str(v.size())+
			".\n");
			value_type = type_notset;
			} else {
			value_type = vti;
			switch (vti) {
			case type_scalar:
			real_value = v[0];
			break;
			case type_3vector:
			case type_unit3vector:
			case type_unit3vectorderiv:
			rvector_value = cvm::rvector(v);
			break;
			case type_quaternion:
			case type_quaternionderiv:
			quaternion_value = cvm::quaternion(v);
			break;
			case type_vector:
			vector1d_value = v;
			break;
			case type_notset:
			default:
			break;
			}
			}
			}


			inline int colvarvalue::check_types(colvarvalue const &x1,
			colvarvalue const &x2)
			{
			if (!colvarvalue::type_checking()) {
			return COLVARS_OK;
			}

			if (x1.type() != x2.type()) {
			if (((x1.type() == type_unit3vector) &&
			(x2.type() == type_unit3vectorderiv)) \|\|
			((x2.type() == type_unit3vector) &&
			(x1.type() == type_unit3vectorderiv)) \|\|
			((x1.type() == type_quaternion) &&
			(x2.type() == type_quaternionderiv)) \|\|
			((x2.type() == type_quaternion) &&
			(x1.type() == type_quaternionderiv))) {
			return COLVARS_OK;
			} else {
			cvm::error("Trying to perform an operation between two colvar "
			"values with different types, \""+
			colvarvalue::type_desc(x1.type())+
			"\" and \""+
			colvarvalue::type_desc(x2.type())+
			"\".\n");
			return COLVARS_ERROR;
			}
			}

			if (x1.type() == type_vector) {
			if (x1.vector1d_value.size() != x2.vector1d_value.size()) {
			cvm::error("Trying to perform an operation between two vector colvar "
			"values with different sizes, "+
			cvm::to_str(x1.vector1d_value.size())+
			" and "+
			cvm::to_str(x2.vector1d_value.size())+
			".\n");
			return COLVARS_ERROR;
			}
			}
			return COLVARS_OK;
			}


			inline int colvarvalue::check_types_assign(colvarvalue::Type const &vt1,
			colvarvalue::Type const &vt2)
			{
			if (!colvarvalue::type_checking()) {
			return COLVARS_OK;
			}

			if (vt1 != type_notset) {
			if (vt1 != vt2) {
			cvm::error("Trying to assign a colvar value with type \""+
			type_desc(vt2)+"\" to one with type \""+
			type_desc(vt1)+"\".\n");
			return COLVARS_ERROR;
			}
			}
			return COLVARS_OK;
			}


			inline void colvarvalue::undef_op() const
			{
			cvm::error("Error: Undefined operation on a colvar of type \""+
			type_desc(this->type())+"\".\n");
			}


			inline colvarvalue & colvarvalue::operator = (colvarvalue const &x)
			{
			check_types_assign(this->type(), x.type());
			value_type = x.type();

			switch (this->type()) {
			case colvarvalue::type_scalar:
			this->real_value = x.real_value;
			break;
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			this->rvector_value = x.rvector_value;
			break;
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			this->quaternion_value = x.quaternion_value;
			break;
			case colvarvalue::type_vector:
			vector1d_value = x.vector1d_value;
			elem_types = x.elem_types;
			elem_indices = x.elem_indices;
			elem_sizes = x.elem_sizes;
			break;
			case colvarvalue::type_notset:
			default:
			undef_op();
			break;
			}
			return *this;
			}


			inline void colvarvalue::operator += (colvarvalue const &x)
			{
			colvarvalue::check_types(*this, x);

			switch (this->type()) {
			case colvarvalue::type_scalar:
			this->real_value += x.real_value;
			break;
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			this->rvector_value += x.rvector_value;
			break;
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			this->quaternion_value += x.quaternion_value;
			break;
			case colvarvalue::type_vector:
			this->vector1d_value += x.vector1d_value;
			break;
			case colvarvalue::type_notset:
			default:
			undef_op();
			}
			}

			inline void colvarvalue::operator -= (colvarvalue const &x)
			{
			colvarvalue::check_types(*this, x);

			switch (value_type) {
			case colvarvalue::type_scalar:
			real_value -= x.real_value;
			break;
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			rvector_value -= x.rvector_value;
			break;
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			quaternion_value -= x.quaternion_value;
			break;
			case colvarvalue::type_vector:
			this->vector1d_value -= x.vector1d_value;
			break;
			case colvarvalue::type_notset:
			default:
			undef_op();
			}
			}


			inline void colvarvalue::operator *= (cvm::real const &a)
			{
			switch (value_type) {
			case colvarvalue::type_scalar:
			real_value *= a;
			break;
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vectorderiv:
			rvector_value *= a;
			break;
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			quaternion_value *= a;
			break;
			case colvarvalue::type_vector:
			this->vector1d_value *= a;
			break;
			case colvarvalue::type_notset:
			default:
			undef_op();
			}
			}


			inline void colvarvalue::operator /= (cvm::real const &a)
			{
			switch (value_type) {
			case colvarvalue::type_scalar:
			real_value /= a; break;
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			rvector_value /= a; break;
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			quaternion_value /= a; break;
			case colvarvalue::type_vector:
			this->vector1d_value /= a;
			break;
			case colvarvalue::type_notset:
			default:
			undef_op();
			}
			}


			inline cvm::vector1d<cvm::real> const colvarvalue::as_vector() const
			{
			switch (value_type) {
			case colvarvalue::type_scalar:
			{
			cvm::vector1d<cvm::real> v(1);
			v[0] = real_value;
			return v;
			}
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			return rvector_value.as_vector();
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			return quaternion_value.as_vector();
			case colvarvalue::type_vector:
			return vector1d_value;
			case colvarvalue::type_notset:
			default:
			return cvm::vector1d<cvm::real>(0);
			}
			}


			inline void colvarvalue::reset()
			{
			switch (value_type) {
			case colvarvalue::type_scalar:
			real_value = 0.0;
			break;
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			rvector_value.reset();
			break;
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			quaternion_value.reset();
			break;
			case colvarvalue::type_vector:
			vector1d_value.reset();
			break;
			case colvarvalue::type_notset:
			default:
			break;
			}
			}


			inline void colvarvalue::apply_constraints()
			{
			switch (value_type) {
			case colvarvalue::type_scalar:
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vectorderiv:
			case colvarvalue::type_quaternionderiv:
			break;
			case colvarvalue::type_unit3vector:
			rvector_value /= std::sqrt(rvector_value.norm2());
			break;
			case colvarvalue::type_quaternion:
			quaternion_value /= std::sqrt(quaternion_value.norm2());
			break;
			case colvarvalue::type_vector:
			if (elem_types.size() > 0) {
			// if we have information about non-scalar types, use it
			size_t i;
			for (i = 0; i < elem_types.size(); i++) {
			if (elem_sizes[i] == 1) continue; // TODO this can be optimized further
			colvarvalue cvtmp(vector1d_value.slice(elem_indices[i],
			elem_indices[i] + elem_sizes[i]), elem_types[i]);
			cvtmp.apply_constraints();
			set_elem(i, cvtmp);
			}
			}
			break;
			case colvarvalue::type_notset:
			default:
			break;
			}
			}


			inline void colvarvalue::is_derivative()
			{
			switch (value_type) {
			case colvarvalue::type_scalar:
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vectorderiv:
			case colvarvalue::type_quaternionderiv:
			break;
			case colvarvalue::type_unit3vector:
			type(colvarvalue::type_unit3vectorderiv);
			break;
			case colvarvalue::type_quaternion:
			type(colvarvalue::type_quaternionderiv);
			break;
			case colvarvalue::type_vector:
			// TODO
			break;
			case colvarvalue::type_notset:
			default:
			break;
			}
			}


			inline cvm::real colvarvalue::norm2() const
			{
			switch (value_type) {
			case colvarvalue::type_scalar:
			return (this->real_value)*(this->real_value);
			case colvarvalue::type_3vector:
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			return (this->rvector_value).norm2();
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			return (this->quaternion_value).norm2();
			case colvarvalue::type_vector:
			if (elem_types.size() > 0) {
			// if we have information about non-scalar types, use it
			cvm::real result = 0.0;
			size_t i;
			for (i = 0; i < elem_types.size(); i++) {
			result += (this->get_elem(i)).norm2();
			}
			return result;
			} else {
			return vector1d_value.norm2();
			}
			break;
			case colvarvalue::type_notset:
			default:
			return 0.0;
			}
			}


			inline cvm::real colvarvalue::dist2(colvarvalue const &x2) const
			{
			colvarvalue::check_types(*this, x2);

			switch (this->type()) {
			case colvarvalue::type_scalar:
			return (this->real_value - x2.real_value)*(this->real_value - x2.real_value);
			case colvarvalue::type_3vector:
			return (this->rvector_value - x2.rvector_value).norm2();
			case colvarvalue::type_unit3vector:
			case colvarvalue::type_unit3vectorderiv:
			// angle between (*this) and x2 is the distance
			return std::acos(this->rvector_value * x2.rvector_value) * std::acos(this->rvector_value * x2.rvector_value);
			case colvarvalue::type_quaternion:
			case colvarvalue::type_quaternionderiv:
			// angle between (*this) and x2 is the distance, the quaternion
			// object has it implemented internally
			return this->quaternion_value.dist2(x2.quaternion_value);
			case colvarvalue::type_vector:
			return (this->vector1d_value - x2.vector1d_value).norm2();
			case colvarvalue::type_notset:
			default:
			this->undef_op();
			return 0.0;
			};
			}


			#endif

lammps/lib/colvars/colvarvalue.hd7fa3ba7185fefficient_neuronet

colvarvalue.hView Options

lammps/lib/colvars/colvarvalue.h
d7fa3ba7185fefficient_neuronet

colvarvalue.h
View Options