spacewrap.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file spacewrap.h
///
/// Helper functions and an auxiliary class for space wrapping.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2014 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 <https://www.gnu.org/licenses/>.
 
// Started on February 11, 2008. Last revision: February 27, 2013.
 
 
#ifndef _CMGRAPHS_SPACEWRAP_H_
#define _CMGRAPHS_SPACEWRAP_H_
 
 
// include selected header files from the CHomP library
#include "chomp/system/config.h"
 
// include local header files
#include "config.h"
#include "typedefs.h"
 
 
// --------------------------------------------------
// -------------- phase space wrapping --------------
// --------------------------------------------------
 
/// Sets the appropriate space wrapping and returns true iff there is
/// some non-trivial wrapping in any direction.
inline bool setSpaceWrapping (int width)
{
        bool wrapping = false;
        spcCoord wrap [2 * spaceDim];
        for (int i = 0; i < spaceDim; ++ i)
        {
                if (spaceWrapping [i])
                {
                        wrapping = true;
                        wrap [i] = wrap [spaceDim + i] = width;
                }
                else
                        wrap [i] = wrap [spaceDim + i] = 0;
        }
        if (wrapping)
        {
                spcCube::PointBase::setwrapping (wrap,
                        spaceDim, 2 * spaceDim + 1);
        }
        return wrapping;
} /* setSpaceWrapping */
 
/// Unsets any space wrapping in the phase space.
inline void unsetSpaceWrapping ()
{
//      const spcCoord zero (0);
        spcCube::PointBase::setwrapping (static_cast<spcCoord> (0));
        return;
} /* unsetSpaceWrapping */
 
/// Sets space wrapping locally.
/// The space wrapping is set in the constructor of the objects
/// of this class, and the space wrapping is unset in the destructor.
class localSpaceWrapping
{
public:
        /// The constructor sets space wrapping.
        localSpaceWrapping (int width):
                wrapping (setSpaceWrapping (width))
        {
                return;
        }
 
        /// The destructor unsets space wrapping.
        ~localSpaceWrapping ()
        {
                if (wrapping)
                        unsetSpaceWrapping ();
                return;
        }
 
        /// Returns true iff space wrapping was set in any direction.
        operator bool () const
        {
                return wrapping;
        }
 
private:
        /// Was space wrapping set in any direction?
        bool wrapping;
 
}; /* class localSpaceWrapping */
 
 
#endif // _CMGRAPHS_SPACEWRAP_H_