Subversion Repositories public iLand

/********************************************************************************************
**    iLand - an individual based forest landscape and disturbance model
**    http://iland.boku.ac.at
**    Copyright (C) 2009-  Werner Rammer, Rupert Seidl
**
**    This program 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 program 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 program.  If not, see <http://www.gnu.org/licenses/>.
********************************************************************************************/

#ifndef SEEDDISPERSAL_H
#define SEEDDISPERSAL_H
#include <QHash>
#include "grid.h"
class Species;

class SeedDispersal
{
public:
    SeedDispersal(Species *species=0): mIndexFactor(10), mSetup(false), mSpecies(species) {}
    ~SeedDispersal();
    bool isSetup() const { return mSetup; }
    void setup();
    //
    static void setupExternalSeeds();
    static void finalizeExternalSeeds();
    // access
    const Grid<float> &seedMap() const { return mSeedMap; } ///< access to the seedMap
    const Species *species() const {return mSpecies; }
    /// setMatureTree is called by individual (mature) trees. This actually fills the initial state of the seed map.
    void setMatureTree(const QPoint &lip_index, double leaf_area) {
        if (mProbMode)
            mSeedMap.valueAtIndex(lip_index.x()/mIndexFactor, lip_index.y()/mIndexFactor)=1.f;
        else
            mSourceMap.valueAtIndex(lip_index.x()/mIndexFactor, lip_index.y()/mIndexFactor) += leaf_area;
    }
    /// extra seed rain of serotinous species at 'position_index'
    void seedProductionSerotiny(const QPoint &position_index);

    // operations
    void clear(); ///< clears the grid
    void execute(); ///< execute the seed dispersal
    bool edgeDetection(Grid<float> *seed_map = 0); ///< phase 1: detect edges in the image; returns false if *no* pixel is 'lit'
    void distribute(Grid<float> *seed_map = 0); ///< phase 2: distribute seeds
    // functions for non-probability mode
    void distributeSeeds(Grid<float> *seed_map=0);
    // debug and helpers
    void loadFromImage(const QString &fileName); ///< debug function...
    void dumpMapNextYear(QString file_name) { mDumpNextYearFileName = file_name; }
private:
    void createKernel(Grid<float> &kernel, const double max_seed, const double scale_area); ///< initializes / creates the kernel
    double setupLDD(); ///< initialize long distance seed dispersal
    double treemig(const double &distance);
    // numerical integration of the treemig function up to a radius 'max_distance'
    double treemig_centercell(const double &max_distance);
    double treemig_distanceTo(const double value);
    bool mProbMode; ///< if 'true', seed dispersal uses probabilities to distribute (old version)
    double mTM_as1, mTM_as2, mTM_ks; ///< seed dispersal paramaters (treemig)
    double mTM_fecundity_cell; ///< maximum seeds per source cell
    double mTM_occupancy; ///< seeds required per destination regeneration pixel
    double mNonSeedYearFraction; ///< fraction of the seed production in non-seed-years
    double mKernelThresholdArea, mKernelThresholdLDD; ///< value of the kernel function that is the threhold for full coverage and LDD, respectively
    int mIndexFactor; ///< multiplier between light-pixel-size and seed-pixel-size
    Grid<float> mSeedMap; ///< (large) seedmap. Is filled by individual trees and then processed
    Grid<float> mSourceMap; ///< (large) seedmap used to denote the sources
    Grid<float> mKernelSeedYear; ///< species specific "seed kernel" (small) for seed years
    Grid<float> mKernelNonSeedYear; ///< species specific "seed kernel" (small) for non-seed-years
    Grid<float> mKernelSerotiny; ///< seed kernel for extra seed rain
    Grid<float> mSeedMapSerotiny; ///< seed map that keeps track of serotiny events
    QVector<double> mLDDDistance; ///< long distance dispersal distances (e.g. the "rings")
    QVector<double> mLDDDensity;  ///< long distance dispersal # of cells that should be affected in each "ring"
    int mLDDRings; ///< # of rings (with equal probability) for LDD
    float mLDDSeedlings; ///< each LDD pixel has this probability
    bool mHasPendingSerotiny; ///< true if active (unprocessed) pixels are on the extra-serotiny map
    bool mSetup;
    Species *mSpecies;
    bool mDumpSeedMaps; ///< if true, seedmaps are stored as images
    bool mHasExternalSeedInput; ///< if true, external seeds are modelled for the species
    QString mDumpNextYearFileName; ///< debug output - dump of the content of the grid to a file during the next execution
    int mExternalSeedDirection; ///< direction of external seeds
    int mExternalSeedBuffer; ///< how many 20m pixels away from the simulation area should the seeding start?
    double mExternalSeedBackgroundInput; ///< background propability for this species; if set, then a certain seed availability is provided for the full area
    // external seeds
    Grid<float> mExternalSeedMap; ///< for more complex external seed input, this map holds that information
    void setupExternalSeedsForSpecies(Species *species); ///< setup of special external seed input
    static Grid<float> *mExternalSeedBaseMap; ///< static intermediate data while setting up external seeds
    static QHash<QString, QVector<double> > mExtSeedData; ///< holds definition of species and percentages for external seed input
    static int mExtSeedSizeX, mExtSeedSizeY; ///< size of the sectors used to specify external seed input
};

#endif // SEEDDISPERSAL_H