PollenNectar.h

Go to the documentation of this file.

//
// PollenNectar.h
//
/*
*******************************************************************************************************
Copyright (c) 2021, Christopher John Topping, Aarhus University
All rights reserved.
 
Version for B-GOOD, Oct. 2023, Xiaodong Duan Aarhus University
 
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:
 
Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/
 
 
#ifndef POLLEN_NECTAR_H
#define POLLEN_NECTAR_H
 
#include <vector>
#include <algorithm>
#include <climits> // gcc built fails without explicitly including climits
#include <Eigen/Dense>
 
 
class PollenNectarDevelopmentCurveSet {
public:
    bool m_flag_not_enough_data = false;
    int m_curve_number;
    double m_DDthreshold = 0;
    double m_MaxDDeg;
    double m_MinFlowerLength;
    double m_MaxFlowerLength;
    double m_MeanFlowerLength;
    double m_StdFlowerLength;
    double m_starting_DD_flowering;
    double m_ending_DD_flowering;
    double m_total_nectar_whole_flowering;
    double m_total_sugar_whole_flowering;
    double m_total_pollen_whole_flowering;
    double m_pollen_quality;
    int m_starting_day_flowering;
    int m_ending_day_flowering;
    int m_flowering_length;
    int m_num_flowering_phases;
    vector <double> m_nectar_per_phase;
    vector <double> m_sugar_per_phase;
    vector <double> m_pollen_per_phase;
    vector <int> m_day_flowering_phases;
    
    double getNectar(int a_given_day) {
        return getResource(a_given_day, m_nectar_per_phase);
    }
 
    double getSugar(int a_given_day) {
        return getResource(a_given_day, m_sugar_per_phase);
    }
 
    double getPollen(int a_given_day) {
        return getResource(a_given_day, m_pollen_per_phase);
    }
 
    double getPollenQuality(int a_given_day){
        if(a_given_day < m_day_flowering_phases.front() || a_given_day > m_day_flowering_phases.back()) return 0;
        else return m_pollen_quality;
    }
 
    double getResource(int a_given_day, vector<double>& a_resource_per_phase) {
        //before or after the flowering period, return 0
        if (a_given_day < m_day_flowering_phases.front() || a_given_day >= m_day_flowering_phases.back()) return 0;
        
        //check which phase the given day is in
        for (int i = 0; i < m_num_flowering_phases; i++) {
            if (a_given_day >= m_day_flowering_phases[i] && a_given_day < m_day_flowering_phases[i + 1]) {
                if(a_resource_per_phase[i] < 0) return 0; //data missing, return 0
                return a_resource_per_phase[i];
            }
        }
    }
 
    PollenNectarDevelopmentCurveSet();
    void ClearAll()
    {
        m_nectar_per_phase.clear();
        m_sugar_per_phase.clear();
        m_pollen_per_phase.clear();
        m_day_flowering_phases.clear();
    }
 
    double GetThreshold() { return m_DDthreshold; }
    double GetMaxDDeg() {return m_MaxDDeg;}
    int GetRef() { return m_curve_number; }
    double GetStartingDDFlowering(void) {return m_starting_DD_flowering;}
    double GetEndingDDFlowering(void) {return m_ending_DD_flowering;}
    int GetStartingDayFlowering(void) {return m_starting_day_flowering;}
    int GetEndingDayFlowering(void) {return m_ending_day_flowering;}
    void SetStartingDayFlowering(int a_starting_day_flowering) {m_starting_day_flowering = a_starting_day_flowering;}
    void SetEndingDayFlowering(int a_ending_day_flowering) {m_ending_day_flowering = a_ending_day_flowering;}
    void UpdateFlowerResource(void);
};
 
class PollenNectarData {
public:
    PollenNectarData();
    PollenNectarData(double a_quantity, double a_quality);
    double m_quantity = 0.0; // The quantity of nectar or pollen
    double m_quality = 0.0;  // The quality of nectar or pollen //Jordan
    double GetNectarSugarConc();
};
 
class PollenNectarDevelopmentData
{
protected:
    Eigen::ArrayXd m_year_temp = Eigen::ArrayXd::Zero(365);
    std::map<int, PollenNectarDevelopmentCurveSet> m_ResourceCurves;
    std::map<int, std::vector<PollenNectarData>> m_pollen_habitat_species;
    std::map<int, std::vector<PollenNectarData>> m_nectar_habitat_species;
    vector<int> m_tov_PollenCurveTable;
    vector<bool> m_tov_PollenCurveTable_sowing_flag;
    int m_num_species_habitat;
    std::map<int, double> m_flower_number_crop;
    
public:
    PollenNectarDevelopmentData(string a_toleinputfile = "default", string a_tovinputfile = "default");
    ~PollenNectarDevelopmentData();
 
    void RecalculatePollenNectarCurvesForYear(void);
 
    void ReadFlowerNumberCrop(void);
 
    PollenNectarDevelopmentCurveSet* tovGetPollenNectarCurve(TTypesOfVegetation a_tov_ref)
    {
        int refnum = m_tov_PollenCurveTable[a_tov_ref];
        return GetPollenNectarCurve(refnum);
    }
 
    int tovGetPollenNectarCurveRef(TTypesOfVegetation a_tov_ref)
    {
        return m_tov_PollenCurveTable[a_tov_ref];
    }
 
    bool tovGetPollenNectarCurveSowingFlag(TTypesOfVegetation a_tov_ref)
    {
        return m_tov_PollenCurveTable_sowing_flag[a_tov_ref];
    }
    
    PollenNectarDevelopmentCurveSet* GetPollenNectarCurve(int a_ref)
    {       
        return &m_ResourceCurves[a_ref];
    }
 
    void updateHabitatFlowerResource(void);
 
    PollenNectarData supplyPollenHabitatSpeciesCurrentDay(int a_curve_num);
    PollenNectarData supplyNectarHabitatSpeciesCurrentDay(int a_curve_num);
    PollenNectarData supplyPollenHabitatSpeciesGivenDay(int a_curve_num, int a_given_day);
    PollenNectarData supplyNectarHabitatSpeciesGivenDay(int a_curve_num, int a_given_day);
};
 
PollenNectarDevelopmentData* CreatePollenNectarDevelopmentData();
 
#endif