p_lorenz.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file p_lorenz.h
///
/// Parameters for the Lorenz equations with 3 parameters.
///
/// @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 June 26, 2012. Last revision: July 2, 2012.
 
 
#ifndef _CMGRAPHS_P_H_
#define _CMGRAPHS_P_H_
 
 
namespace custom {
 
/// Parameters for the Lorenz time-t map with 3 parameters.
namespace lorenz {
 
 
// --------------------------------------------------
// --------- the phase space configuration ----------
// --------------------------------------------------
 
/// The dimension of the phase space.
const int spaceDim = 3;
 
/// Is space wrapping (a.k.a. periodic boundary conditions)
/// in effect in the given directions?
const bool spaceWrapping [spaceDim] = {false, false, false};
 
/// The initial depth of subdivisions in the phase space.
const int initialDepth = 5;
 
/// The final depth of subdivisions in the phase space.
const int finalDepth = 6;
 
 
// --------------------------------------------------
// ------------ the parameter selection -------------
// --------------------------------------------------
 
/// The dimension of the parameter space to iterate. Only those parameters
/// which are varying are taken into consideration here.
const int paramDim = 3;
 
/// The numbers of subintervals in each direction of the parameter space.
/// The type of these numbers must match "parCoord" in "typedefs.h".
const short int paramSubdiv [paramDim] = {1, 1, 1};
 
/// The numbers of parameters to subdivide.
const int paramSelect [paramDim] = {0, 1, 2};
 
 
// --------------------------------------------------
// ---------- the parameter space settings ----------
// --------------------------------------------------
 
/// The number of all the parameters, both varying and fixed.
const int paramCount = 3;
 
/// Half of the width of the parameter interval.
const double epsilonParam = 0;
 
/// The left bounds on the parameters.
const double paramLeft [paramCount] =
        {10 - epsilonParam, 28 - epsilonParam, 8.0 / 3 - epsilonParam};
 
/// The right bounds on the parameters.
const double paramRight [paramCount] =
        {10 + epsilonParam, 28 + epsilonParam, 8.0 / 3 + epsilonParam};
 
 
// --------------------------------------------------
// -------------- the phase space size --------------
// --------------------------------------------------
 
// An array which keeps the offset of the rectangular area
// in the phase space that contains the invariant sets of interest.
//const double spaceOffset [spaceDim] = {-16, -20, -5};
 
// An array which keeps the width of the rectangular area
// in the phase space that contains the invariant sets of interest.
//const double spaceWidth [spaceDim] = {32, 40, 40};
 
 
/// An imitation of an array which returns the offset of the rectangular area
/// in the phase space which contains the invariant sets of interest.
struct SpaceOffsetType
{
        /// Returns the space offset in the requested direction.
        double operator [] (int n) const
        {
                // for rho = 13
                if (paramLeft [1] <= 13)
                {
                        const double offset [] = {-16, -20, -5};
                        return offset [n];
                }
                // for rho = 18
                else if (paramLeft [1] <= 18)
                {
                        const double offset [] = {-20, -25, -5};
                        return offset [n];
                }
                // for rho = 28
                else
                {
                        const double offset [] = {-25, -35, -5};
                        return offset [n];
                }
        }
}; /* struct SpaceOffsetType */
 
/// An imitation of an array which returns the offset of the rectangular area
/// in the phase space which contains the invariant sets of interest.
const SpaceOffsetType spaceOffset = SpaceOffsetType ();
 
/// An imitation of an array which returns the width of the rectangular area
/// in the phase space which contains the invariant sets of interest.
struct SpaceWidthType
{
        /// Returns the space width in the requested direction.
        double operator [] (int n) const
        {
                // for rho = 13
                if (paramLeft [1] <= 13)
                {
                        const double width [] = {32, 40, 40};
                        return width [n];
                }
                // for rho = 18
                else if (paramLeft [1] <= 18)
                {
                        const double width [] = {40, 50, 50};
                        return width [n];
                }
                // for rho = 28
                else
                {
                        const double width [] = {50, 70, 70};
                        return width [n];
                }
        }
}; /* struct SpaceWidthType */
 
/// An imitation of an array which returns the width of the rectangular area
/// in the phase space which contains the invariant sets of interest.
const SpaceWidthType spaceWidth = SpaceWidthType ();
 
 
// --------------------------------------------------
// ------------------ refinements -------------------
// --------------------------------------------------
 
/// The number of refinements that should be done if a Morse set
/// with the trivial index is encountered or if the image of a Morse set
/// sticks out of the rectangular region to which the computations
/// are restricted. Set to zero for no refinements.
const int refineDepth = 2;
 
/// The maximal allowed size of a set of cubes in the phase space
/// which can be refined at the initial subdivision level.
/// Set to zero to suppress any refinements.
const int maxRefineSize0 = 1000;
 
/// The maximal allowed size of a set of cubes in the phase space
/// which can be refined at the subsequent subdivision levels.
/// Set to zero to suppress any refinements.
const int maxRefineSize1 = 1000;
 
 
// --------------------------------------------------
// ------------------- map images -------------------
// --------------------------------------------------
 
/// The maximal allowed diameter of the cubical image of a signle box.
/// This limit is set up in order to prevent a blow-up of the program
/// in the memory because of accumulating huge images of boxes.
const int maxImageDiameter = 10000;
 
/// The maximal allowed volume of the cubical image of a single box.
/// This limit is set up in order to prevent a blow-up of the program
/// in the memory because of accumulating huge images of boxes.
const int maxImageVolume = 1000000;
 
 
// --------------------------------------------------
// -------------- max index pair size ---------------
// --------------------------------------------------
 
/// The maximal allowed size of the index pair. This size is measured
/// as the total number of cubes in the index pair and its forward image.
const int maxIndexPairSize = 1000000;
 
 
// --------------------------------------------------
// --------------- joining Morse sets ---------------
// --------------------------------------------------
 
/// The maximal number of cubes in a trivial Morse set for which an attempt
/// is made to join this set with another near-by Morse set.
/// Set to zero to suppress joining.
const int maxJoinSize = 0;
 
/// The maximal size of a connecting orbit between two Morse sets
/// which can be considered for joining.
const int maxJoinConnection = 1000;
 
/// The maximal allowed distance between two Morse sets which can be
/// considered for joining. Note: It doesn't work with space wrapping.
const int maxJoinDistance = 100;
 
 
// --------------------------------------------------
// ----------------- other settings -----------------
// --------------------------------------------------
 
/// Should the ordering between the Morse sets be taken into consideration
/// while determining whether two Morse decompositions
/// computed for adjacent parameter boxes are in the same class?
const bool compareMorseOrdering = false;
 
/// Ignoring the isolation problem while matching Morse decompositions.
/// If this constant is set to "true" then Morse sets are matched
/// with each other indepent of whether the Conley index could be computed
/// for them or not. Otherwise, 'correct' and 'wrong' Morse sets
/// are matched with their counterparts in the same category only.
const bool ignoreIsolationForContinuation = true;
 
/// Ignoring the isolation problem while computing the Conley index.
/// If the constant is set to "true" then the index pair constructed on the
/// basis of a combinatorial Morse set with respect to the dynamics
/// restricted to the rectangular area of interest is also restricted
/// to that area by means of projecting all the boxes that stick out
/// of the region onto a single layer of boxes around the boundary.
const bool ignoreIsolationForConleyIndex = false;
 
 
} // namespace lorenz
} // namespace custom
 
 
#endif // _CMGRAPHS_P_H_