wrapping.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// Tools for coordinate wrapping, a.k.a. periodic boundary conditions.
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 2009-2016 by Pawel Pilarczyk.
//
// This file is part of my research software package. This is free software:
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software; see the file "license.txt". If not,
// please, see <http://www.gnu.org/licenses/>.

// Started on March 24, 2009. Last revision: January 13, 2013.


#ifndef _CHAINCON_WRAPPING_H_
#define _CHAINCON_WRAPPING_H_


// include some standard C++ header files
#include <vector>
#include <string>
#include <istream>
#include <sstream>

// include selected header files from the CHomP library
//#include "chomp/system/config.h"
//#include "chomp/system/textfile.h"


// --------------------------------------------------
// ------------------ no wrapping -------------------
// --------------------------------------------------

/// A simple class for wrapping cubical cell coordinstes,
/// which does not wrap anything.
template <class CoordT>
class NoWrapping
{
public:
        /// The type of coordinates for wrapping.
        typedef CoordT CoordType;

        /// A dummy wrapping function that does nothing.
        template <class ArrayT>
        static void wrap (ArrayT &coords, int dim);

        /// A dummy function for setting wrapping that throws an exception
        /// if called.
        template <class ArrayT>
        static void setWrapping (const ArrayT &coords, int dim);

}; /* class NoWrapping */

// --------------------------------------------------

template <class CoordT>
template <class ArrayT>
inline void NoWrapping<CoordT>::wrap (ArrayT &, int)
{
        return;
} /* NoWrapping::wrap */

template <class CoordT>
template <class ArrayT>
inline void NoWrapping<CoordT>::setWrapping (const ArrayT &, int)
{
        throw "Coordinate wrapping not supported.";
        return;
} /* SettableWrapping::setWrapping */


// --------------------------------------------------
// --------------- settable wrapping ----------------
// --------------------------------------------------

/// A simple class for wrapping cubical cell coordinstes,
/// using the one defined in the CHomP package.
template <class CoordT>
class SettableWrapping
{
public:
        /// The type of coordinates for wrapping.
        typedef CoordT CoordType;

        /// Makes a correction to the given array of coordinates
        /// if wrapping is in effect.
        template <class ArrayT>
        static void wrap (ArrayT &coords, int dim);

        /// Sets wrapping for all spaces of the given dimension.
        template <class ArrayT>
        static void setWrapping (const ArrayT &coords, int dim);

private:
        /// An array of wrapping vectors for each dimension where defined.
        static std::vector<std::vector<CoordT> > wrapping;

}; /* class SettableWrapping */

// --------------------------------------------------

template <class CoordT>
std::vector<std::vector<CoordT> > SettableWrapping<CoordT>::wrapping;

// --------------------------------------------------

template <class CoordT>
template <class ArrayT>
inline void SettableWrapping<CoordT>::wrap (ArrayT &coords, int dim)
{
        // if wrapping was not defined for this dimension then do nothing
        if (static_cast<int> (wrapping. size ()) <= dim)
                return;
        const std::vector<CoordT> &w (wrapping [dim]);
        if (static_cast<int> (w. size ()) != dim)
                return;

        // wrap those coordinates which require this
        for (int i = 0; i < dim; ++ i)
        {
                if (!w [i])
                        continue;
                if (coords [i] >= 0)
                {
                        if (coords [i] < w [i])
                        {
                        }
                        else if (coords [i] == w [i])
                        {
                                coords [i] = 0;
                        }
                        else if (coords [i] > w [i])
                        {
                                coords [i] %= w [i];
                        }
                }
                else if (coords [i] == -1)
                {
                        coords [i] = w [i] - 1;
                }
                else
                {
                        coords [i] = (w [i] - 1) -
                                ((-coords [i] - 1) % w [i]);
                }
        }

        return;
} /* SettableWrapping::wrap */

template <class CoordT>
template <class ArrayT>
inline void SettableWrapping<CoordT>::setWrapping
        (const ArrayT &coords, int dim)
{
        // extend the wrapping vector if necessary
        while (static_cast<int> (wrapping. size ()) <= dim)
        {
                std::vector<CoordT> dummy;
                wrapping. push_back (dummy);
        }

        // create a new vector for wrapping coordinates at the given dim
        std::vector<CoordT> w (dim);
        for (int i = 0; i < dim; ++ i)
                w [i] = coords [i];

        // put the new vector in the wrapping array
        wrapping [dim] = w;

        return;
} /* SettableWrapping::setWrapping */

// --------------------------------------------------

/// Sets wrapping based on a text with comma-separated numbers.
/// The dimension in which the wrapping is set is determined automatically
/// as the number of the provided numbers.
/// All the numbers must be non-negative.
template <class WrapT>
inline void setWrapping (const std::string &s)
{
        typedef typename WrapT::CoordType CoordType;
        std::vector<CoordType> coords;
        std::istringstream in (s);
        while (in. peek () != EOF)
        {
                CoordType n (-1);
                in >> n;
                if (n == static_cast<CoordType> (-1))
                        break;
                coords. push_back (n);
                if (in. peek () == ',')
                        in. get ();
        }
        if (!coords. empty ())
                WrapT::setWrapping (coords, coords. size ());
        return;
} /* setWrapping */


#endif // _CHAINCON_WRAPPING_H_