Subversion Repositories public iLand

/** @class ResourceUnit

  ResourceUnit is the spatial unit that encapsulates a forest stand and links to several environmental components

  (Climate, Soil, Water, ...).

  */

#include <QtCore>

#include "global.h"

#include "resourceunit.h"

#include "resourceunitspecies.h"

#include "speciesset.h"

#include "species.h"

#include "production3pg.h"

#include "model.h"

#include "climate.h"

ResourceUnit::ResourceUnit(const int index)

{

    mSpeciesSet = 0;

    mClimate = 0;

    mIndex = index;

    mTrees.reserve(100); // start with space for 100 trees.

}

/// set species and setup the species-per-RU-data

void ResourceUnit::setSpeciesSet(SpeciesSet *set)

{

    mSpeciesSet = set;

    mRUSpecies.clear();

    mRUSpecies.resize(set->count()); // ensure that the vector space is not relocated

    for (int i=0;i<set->count();i++) {

        Species *s = const_cast<Species*>(mSpeciesSet->species(i));

        if (!s)

            throw IException("ResourceUnit::setSpeciesSet: invalid index!");

        /* be careful: setup() is called with a pointer somewhere to the content of the mRUSpecies container.

           If the container memory is relocated (QVector), the pointer gets invalid!!!

           Therefore, a resize() is called before the loop (no resize()-operations during the loop)! */

        mRUSpecies[i].setup(s,this); // setup this element

    }

}

ResourceUnitSpecies &ResourceUnit::resourceUnitSpecies(const Species *species)

{

    return mRUSpecies[species->index()];

}

Tree &ResourceUnit::newTree()

{

    // start simple: just append to the vector...

    mTrees.append(Tree());

    return mTrees.back();

}

/// remove dead trees from tree list

/// reduce size of vector if lots of space is free

/// tests showed that this way of cleanup is very fast,

/// because no memory allocations are performed (simple memmove())

/// when trees are moved.

void ResourceUnit::cleanTreeList()

{

    QVector<Tree>::iterator last=mTrees.end()-1;

    QVector<Tree>::iterator current = mTrees.begin();

    while (last>=current && (*last).isDead())

        --last;

    while (current<last) {

        if ((*current).isDead()) {

            *current = *last; // copy data!

            --last; //

            while (last>=current && (*last).isDead())

                --last;

        }

        ++current;

    }

    ++last; // last points now to the first dead tree

    // free ressources

    mTrees.erase(last, mTrees.end());

    if (mTrees.capacity()>100) {

        if (mTrees.count() / double(mTrees.capacity()) < 0.2) {

            int target_size = mTrees.count()*2;

            qDebug() << "reduce size from "<<mTrees.capacity() << "to" << target_size;

            mTrees.reserve(qMax(target_size, 100));

        }

    }

}

void ResourceUnit::newYear()

{

    mAggregatedWLA = 0.f;

    mAggregatedLA = 0.f;

    mPixelCount = mStockedPixelCount = 0;

    // clear statistics global and per species...

}

/** production() is the "stand-level" part of the biomass production (3PG).

    - The amount of radiation intercepted by the stand is calculated

    - The 3PG production for each species and ressource unit is invoked  */

void ResourceUnit::production()

{

    mStatistics.clear();

    if (mAggregatedWLA==0 || mPixelCount==0) {

        // nothing to do...

        return;

    }

    // the pixel counters are filled during the height-grid-calculations

    mStockedArea = 100. * mStockedPixelCount; // m2 (1 height grid pixel = 10x10m)

    // calculate the leaf area index (LAI)

    double LAI = mAggregatedLA / mStockedArea;

    // calculate the intercepted radiation fraction using the law of Beer Lambert

    const double k = Model::settings().lightExtinctionCoefficient;

    double interception_fraction = 1. - exp(-k * LAI);

    // calculate the total weighted leaf area on this RU:

    mEffectiveArea_perWLA = interception_fraction *  mStockedArea / mAggregatedWLA;

    DBGMODE(qDebug() << QString("production: LAI: %1 (intercepted fraction: %2, stocked area: %4). Effective Area / wla: %3")

            .arg(LAI)

            .arg(interception_fraction)

            .arg(mEffectiveArea_perWLA)

            .arg(mStockedArea);

    );

    // invoke species specific calculation (3PG)

    //QVector<ResourceUnitSpecies>::iterator i;

    ResourceUnitSpecies *i;

    QVector<ResourceUnitSpecies>::iterator iend = mRUSpecies.end();

    for (i=mRUSpecies.begin(); i!=iend; ++i) {

        i->calculate();

        i->statistics().clear();

        qDebug() << "species" << (*i).species()->id() << "raw_gpp_m2" << i->prod3PG().GPPperArea();

    }

}

void ResourceUnit::yearEnd()

{

    // calculate statistics for all tree species of the ressource unit

    int c = mRUSpecies.count();

    for (int i=0;i<c; i++) {

        mRUSpecies[i].statistics().calculate();

        mStatistics.add(mRUSpecies[i].statistics());

    }

    mStatistics.calculate(); // aggreagte on stand level

}

void ResourceUnit::createStandStatistics()

{

    // clear statistics

    mStatistics.clear();

    for (int i=0;i<mRUSpecies.count();i++)

        mRUSpecies[i].statistics().clear();

    // for all trees

    foreach(const Tree &t, mTrees) {

        if (!t.isDead())

            resourceUnitSpecies(t.species()).statistics().add(&t);

    }

    // summarize statistics

    for (int i=0;i<mRUSpecies.count();i++) {

        mRUSpecies[i].statistics().calculate();

        mStatistics.add(mRUSpecies[i].statistics());

    }

}