parpop2s.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file parpop2s.h
///
/// Parameters for a sample Leslie population model in R^2
/// with 2 varying parameters. The third parameter is of non-zero size,
/// and corresponds to a slice of the computation with 3 varyinf parameters.
/// This is a configuration file for the program "cmgraphs.cpp"
/// which defines the ranges of parameters to scan
/// and the details of the phase space.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 1997-2008 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 2 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, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started on February 9, 2008. Last revision: March 7, 2008.


#ifndef _CMGRAPHS_PARPOP2S_H_
#define _CMGRAPHS_PARPOP2S_H_


namespace custom {

/// Parameters for sample computations for the 2-dimensional Leslie
/// population model with 2 varying parameters.
namespace pop2s {


// --------------------------------------------------
// --------- the phase space configuration ----------
// --------------------------------------------------

/// The dimension of the phase space.
const int spaceDim = 2;

/// The initial depth of subdivisions in the phase space.
const int initialDepth = 6;

/// The final depth of subdivisions in the phase space.
const int finalDepth = 12;


// --------------------------------------------------
// ------------ 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 = 2;

/// 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] = {80, 80};

/// The numbers of parameters to subdivide.
const int paramSelect [paramDim] = {0, 1};


// --------------------------------------------------
// ---------- the parameter space settings ----------
// --------------------------------------------------

/// The number of all the parameters, both varying and fixed.
const int paramCount = 2 * spaceDim;

/// The left bounds on the parameters.
const double paramLeft [paramCount] = {8, 3, 0.5, 0.1};

/// The right bounds on the parameters.
const double paramRight [paramCount] = {37, 50, 0.51, 0.1};


// --------------------------------------------------
// -------------- the phase space size --------------
// --------------------------------------------------

/// 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
        {
                return -0.001;
        }
}; /* 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
{
        /// The constructor which computes the space width in each direction.
        SpaceWidthType ()
        {
                double e = 2.7182818284590453;
                double addError = 1.00000000000001;
                double sumTheta = 0;
                for (int i = 0; i < spaceDim; ++ i)
                {
                        sumTheta += paramRight [i];
                        sumTheta *= addError;
                }
                double t = paramLeft [2 * spaceDim - 1] * e * addError;
                double r = (sumTheta / t) * addError;
                width [0] = (r - spaceOffset [0]) * addError;
                for (int i = 1; i < spaceDim; ++ i)
                {
                        r = (r * paramRight [spaceDim + i - 1]) * addError;
                        width [i] = (r - spaceOffset [i]) * addError;
                }
                return;
        }

        /// Returns the precomputed value of the space width
        /// in the requested direction.
        double operator [] (int n) const
        {
                if ((n < 0) || (n >= spaceDim))
                        throw "Incorrect phase space width requested.";
                return width [n];
        }

private:
        double width [spaceDim];

}; /* 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 ();


// --------------------------------------------------
// --------------- 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.
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 = true;

/// 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 the any boxes which stick out
/// of the region onto a single layer of boxes around the boundary.
const bool ignoreIsolationForConleyIndex = false;


} // namespace pop2s
} // namespace custom


#endif // _CMGRAPHS_PARPOP2S_H_

---