indpop2d.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file indpop2d.h
///
/// Known Conley indices for a dynamical system.
/// Alter this file every time a different system is considered.
///
/// @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 April 5, 2008. Last revision: April 5, 2008.
 
 
#ifndef _CMGRAPHS_INDPOP2D_H_
#define _CMGRAPHS_INDPOP2D_H_
 
// include selected header files from the CHomP library
#include "chomp/system/textfile.h"
#include "chomp/homology/chains.h"
#include "chomp/struct/integer.h"
 
// include local header files
#include "config.h"
#include "typedefs.h"
#include "conindex.h"
#include "morsedec.h"
#include "typedyns.h"
 
 
namespace custom {
 
/// Customized version of a function for the computation of Conley indices
/// of Morse sets which fail the isolation condition.
/// This version is valid for the 2-dimensional Leslie population model
/// and returns the Conley index of the origin if the Morse set
/// seems to be a small neighborhood of the origin.
namespace popOriginInd2d {
 
 
// --------------------------------------------------
// ---------------- set Conley index ----------------
// --------------------------------------------------
 
/// Assigns a prescribed Conley index to the given Morse set
/// whose index could not be computed because of the lack of isolation.
/// This procedure assigns the known index of the origin
/// for the Leslie population model which comes from the linearization,
/// based on its eigenvalues computed by hand for the 2-dimensional model:
/// lambda_1 = theta_1 and lambda_2 = -p theta_2 / theta_1.
/// Returns "true" if the index was set, "false" otherwise.
inline bool setConleyIndex (theMorseDecompositionType &morseDec, int n,
        int subdivDepth, const double *leftMapParam,
        const double *rightMapParam, int paramCount)
{
        using chomp::homology::sbug;
 
        // make sure that the dimension of the phase space is correct
        if (spaceDim != 2)
                return false;
 
        // make sure that the ranges of parameters are good
        if (leftMapParam [0] <= 1.0)
                return false;
        bool repelling = false;
        double addError = 1.00000000000001;
        if (leftMapParam [2] * leftMapParam [1] / rightMapParam [0] /
                addError > 1)
        {
                repelling = true;
        }
        else if (rightMapParam [2] * rightMapParam [1] / leftMapParam [0] *
                addError < 1)
        {
                repelling = false;
        }
        else
                return false;
 
        // if the set is quite large then skip it
        if (morseDec [n]. size () > 10)
                return false;
 
        // determine a cube which covers the origin
        spcCoord origin [spaceDim];
        for (int i = 0; i < spaceDim; ++ i)
        {
                origin [i] = static_cast<spcCoord> (-spaceOffset [i] *
                        (1 << subdivDepth) / spaceWidth [i]);
        }
 
        // if the set does not contain the origin then skip it
        if (!morseDec [n]. check (spcCube (origin, spaceDim)))
                return false;
 
        // set the Conley index of the origin according to the parameters
        int betti [spaceDim + 1];
        chomp::homology::mmatrix<chomp::homology::integer>
                matr [spaceDim + 1];
        for (int i = 0; i <= spaceDim; ++ i)
                betti [i] = 0;
        chomp::homology::integer e;
        e = 1;
        if (!repelling)
        {
                betti [1] = 1;
                matr [1]. add (0, 0, e);
        }
        else
        {
                betti [2] = 1;
                matr [2]. add (0, 0, -e);
        }
        theConleyIndexType ind;
        ind. define (betti, matr, spaceDim);
        morseDec. setindex (n, ind);
        return true;
} /* setConleyIndex */
 
 
} // namespace popOriginInd2d
} // namespace custom
 
 
#endif // _CMGRAPHS_INDPOP2D_H_