PollenNectarDevelopmentData Class Reference

A standard class to manage a range of pollen and nectar development curves based on indexed rates. More...

#include <plants.h>

Public Member Functions
PollenNectarDevelopmentCurveSet	GetPollenNectarCurvePtr (int a_almassLEref)
	PollenNectarDevelopmentData (string a_tovinputfile, string a_toleinputfile, Landscape *a_land)
double	toleGetNectar (int a_tole, int a_index)
int	toleGetNPCurveNum (TTypesOfVegetation a_tov)
double	toleGetPollen (int a_tole, int a_index)
double	tovGetNectar (int a_tov, int a_index)
int	tovGetNPCurveNum (TTypesOfVegetation a_tov)
double	tovGetPollen (int a_tov, int a_index)
PollenNectarDevelopmentCurveSet	tovGetPollenNectarCurvePtr (int a_tov_ref)
	~PollenNectarDevelopmentData ()

Protected Attributes
vector< int >	m_tole_pollencurvetable
vector< PollenNectarDevelopmentCurve * >	m_toleNectarCurves
vector< PollenNectarDevelopmentCurve * >	m_tolePollenCurves
vector< int >	m_tov_pollencurvetable
vector< PollenNectarDevelopmentCurve * >	m_tovNectarCurves
vector< PollenNectarDevelopmentCurve * >	m_tovPollenCurves

Detailed Description

A standard class to manage a range of pollen and nectar development curves based on indexed rates.

Definition at line 224 of file plants.h.

Constructor & Destructor Documentation

PollenNectarDevelopmentData()

PollenNectarDevelopmentData::PollenNectarDevelopmentData	(	string	a_tovinputfile,
		string	a_toleinputfile,
		Landscape *	a_land
	)

Reads in the number of pollen and nectar curves. Either we have one pair for each tov or we need a look-up table, but because many have the same curves a look up table was used. This however requires another input file for tov types to pollen/nectar curve number. If not using pollen and nectar then this is waste of space, so there is a cfg to turn it off and set all curves to a zero curve.

There are two sets of data structures - some based on tole types and the rest are crops that can be on a field tole. the methods of input is duplicated as far as possible.

tov
We need to open the input file and read in the tov types that have associated curves. Those not specified are assumed to have no nectar or pollen. Numbers used are those defined in LE_TypeClass::TranslateVegTypes for each tov type. First file entry is the number of defined tov_types, followed by pairs of tov_refnum & pollen curve refnum. The next line has a single number for the number of pollen/nectar curves The next lines are in pairs, pollen curve followed by nectar curve each with 365 entries and preceded by the curve number.

tole
We need to open the input file and read in the tov types that have associated curves. Those not specified are assumed to have no nectar or pollen. Numbers used are those defined in LE_TypeClass::TranslateEleTypes for each tole type. First file entry is the number of defined tole_types, followed by pairs of tole_refnum & pollen curve refnum. The next line has a single number for the number of pollen/nectar curves The next lines are in pairs, pollen curve followed by nectar curve each with 365 entries and preceded by the curve number.

Definition at line 416 of file plants.cpp.

{
        // This forms an empty entry for no pollen or nectar tov types
        vector<double> empty;
        vector<int> index;
        for (int i = 0; i < 366; i++) {
                empty.push_back(0.0);
                index.push_back(i);
        }
        // make space in the lookup table for all tov types
        m_tov_pollencurvetable.resize(tov_Undefined);
        for (int i = 0; i < int(tov_Undefined); i++) m_tov_pollencurvetable[i] = 0;
        // make space in the lookup table for all tole types
        m_tole_pollencurvetable.resize(tole_Foobar);
        for (int i = 0; i < int(tole_Foobar); i++) m_tole_pollencurvetable[i] = 0;
 
        if (cfg_pollen_nectar_on.value())
        {
                ifstream infile(a_tovinputfile.c_str(), ios::in);
                //check if there is an input file
                if (!infile.is_open()) {
                        g_msg->Warn("PollenNectarDevelopmentData::PollenNectarDevelopmentData Cannot open the file", a_toleinputfile.c_str());
                        exit(1);
                }
                int no_curves;
                int tov, curvenum;
                infile >> no_curves;
                for (int i = 0; i < no_curves-1; i++)
                {
                        infile >> tov >> curvenum;
                        // convert from the reference number to tov type
                        tov = a_land->TranslateVegTypes(tov);
                        // store the reference in the pollen nectar lookup table
                        m_tov_pollencurvetable[tov] = curvenum;
                }
                // Now read the curve themselves
                m_tovPollenCurves.resize(no_curves);
                m_tovNectarCurves.resize(no_curves);
                // each curve is composed to two sets of 365 numbers. The first being the index set - always 1-365 so there is no need to read this in, so it is filled in here
                vector<double> slopes(366, 0);
                PollenNectarDevelopmentCurve * p_curve;
                p_curve = new PollenNectarDevelopmentCurve(&index, &empty);
                m_tovPollenCurves[0] = p_curve;
                m_tovNectarCurves[0] = p_curve;
                for (int i = 0; i < no_curves; i++)
                {
                        // Read the curve number
                        infile >> curvenum; 
                        infile >> slopes[365];
                        // Read in the pollen data and save
                        for (int d = 0; d < 365; d++) infile >> slopes[d];
                        p_curve = new PollenNectarDevelopmentCurve(&index, &slopes);
                        m_tovPollenCurves[curvenum] = p_curve;
                        // Read in the nectar data and save
                        infile >> slopes[365];
                        for (int d = 0; d < 365; d++) infile >> slopes[d];
                        p_curve = new PollenNectarDevelopmentCurve(&index, &slopes);
                        m_tovNectarCurves[curvenum] = p_curve;
                }
                infile.close();
                infile.open(a_tovinputfile.c_str(), ios::in);
                //check if there is an input file
                if (!infile.is_open()) {
                        g_msg->Warn("PollenNectarDevelopmentData::PollenNectarDevelopmentData Cannot open the file", a_toleinputfile.c_str());
                        exit(1);
                }
                infile >> no_curves;
                int tole, tolecurvenum;
                for (int i = 0; i < no_curves-1; i++)
                {
                        infile >> tole >> tolecurvenum;
                        // convert from the reference number to tov type
                        tole = a_land->TranslateVegTypes(tole);
                        // store the reference in the pollen nectar lookup table
                        m_tole_pollencurvetable[tole] = tolecurvenum;
                }
                // Now read the curve themselves
                m_tolePollenCurves.resize(no_curves);
                m_toleNectarCurves.resize(no_curves);
                p_curve = new PollenNectarDevelopmentCurve(&index, &empty);
                m_tolePollenCurves[0] = p_curve;
                m_toleNectarCurves[0] = p_curve;
                for (int i = 1; i <= no_curves; i++)
                {
                        // Read the curve number
                        infile >> tolecurvenum;
                        // Read in the pollen data and save
                        infile >> slopes[366];
                        for (int d = 0; d < 365; d++) infile >> slopes[d];
                        p_curve = new PollenNectarDevelopmentCurve(&index, &slopes);
                        m_tolePollenCurves[tolecurvenum] = p_curve;
                        // Read in the nectar data and save
                        infile >> slopes[365];
                        for (int d = 0; d < 365; d++) infile >> slopes[d];
                        p_curve = new PollenNectarDevelopmentCurve(&index, &slopes);
                        m_toleNectarCurves[tolecurvenum] = p_curve;
                }
                infile.close();
        }
        else
        {
                PollenNectarDevelopmentCurve*  pnc = new PollenNectarDevelopmentCurve(&index, &empty);
                // Set all to zero curve
                m_tovPollenCurves.push_back(pnc);
                m_tovNectarCurves.push_back(pnc);
                m_tolePollenCurves.push_back(pnc);
                m_toleNectarCurves.push_back(pnc);
                for (int tov = 0; tov<int(tov_Undefined); tov++)
                {
                        m_tov_pollencurvetable[tov] = 0;
                }
                for (int tole = 0; tole<int(tole_Foobar); tole++)
                {
                        m_tole_pollencurvetable[tole] = 0;
                }
        }
}

References cfg_pollen_nectar_on, g_msg, m_tole_pollencurvetable, m_toleNectarCurves, m_tolePollenCurves, m_tov_pollencurvetable, m_tovNectarCurves, m_tovPollenCurves, tole_Foobar, tov_Undefined, Landscape::TranslateVegTypes(), CfgBool::value(), and MapErrorMsg::Warn().

~PollenNectarDevelopmentData()

PollenNectarDevelopmentData::~PollenNectarDevelopmentData

(

)

Definition at line 558 of file plants.cpp.

{
        for (int i = 0; i < m_tovPollenCurves.max_size(); i++) delete m_tovPollenCurves[i];
        for (int i = 0; i < m_tovNectarCurves.max_size(); i++) delete m_tovNectarCurves[i];
        for (int i = 0; i < m_tolePollenCurves.max_size(); i++) delete m_tolePollenCurves[i];
        for (int i = 0; i < m_toleNectarCurves.max_size(); i++) delete m_toleNectarCurves[i];
}

References m_toleNectarCurves, m_tolePollenCurves, m_tovNectarCurves, and m_tovPollenCurves.

Member Function Documentation

GetPollenNectarCurvePtr()

PollenNectarDevelopmentCurveSet PollenNectarDevelopmentData::GetPollenNectarCurvePtr

(

int

a_almassLEref

)

Uses the almass LE ref num to find the relevant curve set and return it as a pointer. Zero is a special case since this is the empty pollen/nectar curve - it is not an almass LE ref The other special case is rotational crop field, in which case the initialisation is done when the crop is assigned

Definition at line 566 of file plants.cpp.

{
        PollenNectarDevelopmentCurveSet set;
        set.m_pollencurveptr = m_tolePollenCurves[0];;
        set.m_nectarcurveptr = m_toleNectarCurves[0];;
        if ((a_almassLEref == 0) || (g_letype->TranslateEleTypes(a_almassLEref) == tole_Field) || (g_letype->TranslateEleTypes(a_almassLEref) == tole_UnsprayedFieldMargin)) return set;
        set.m_pollencurveptr = m_tolePollenCurves[m_tole_pollencurvetable[g_letype->TranslateEleTypes(a_almassLEref)]];
        set.m_nectarcurveptr = m_toleNectarCurves[m_tole_pollencurvetable[g_letype->TranslateEleTypes(a_almassLEref)]];
        return set;
}

References g_letype, PollenNectarDevelopmentCurveSet::m_nectarcurveptr, PollenNectarDevelopmentCurveSet::m_pollencurveptr, m_tole_pollencurvetable, m_toleNectarCurves, m_tolePollenCurves, tole_Field, tole_UnsprayedFieldMargin, and LE_TypeClass::TranslateEleTypes().

Referenced by LE::SetPollenNectarData().

toleGetNectar()

double PollenNectarDevelopmentData::toleGetNectar ( int  a_tole, int  a_index  )

inline

Definition at line 230 of file plants.h.

{ return m_toleNectarCurves[int(a_tole)]->GetData(a_index); }

toleGetNPCurveNum()

int PollenNectarDevelopmentData::toleGetNPCurveNum ( TTypesOfVegetation  a_tov )

inline

Definition at line 234 of file plants.h.

{ return m_tole_pollencurvetable[a_tov]; }

toleGetPollen()

double PollenNectarDevelopmentData::toleGetPollen ( int  a_tole, int  a_index  )

inline

Definition at line 229 of file plants.h.

{ return m_tolePollenCurves[int(a_tole)]->GetData(a_index); }

tovGetNectar()

double PollenNectarDevelopmentData::tovGetNectar ( int  a_tov, int  a_index  )

inline

Definition at line 232 of file plants.h.

{ return m_tovNectarCurves[int(a_tov)]->GetData(a_index); }

tovGetNPCurveNum()

int PollenNectarDevelopmentData::tovGetNPCurveNum ( TTypesOfVegetation  a_tov )

inline

Definition at line 233 of file plants.h.

{ return m_tov_pollencurvetable[a_tov]; }

tovGetPollen()

double PollenNectarDevelopmentData::tovGetPollen ( int  a_tov, int  a_index  )

inline

Definition at line 231 of file plants.h.

{ return m_tovPollenCurves[int(a_tov)]->GetData(a_index); }

tovGetPollenNectarCurvePtr()

PollenNectarDevelopmentCurveSet PollenNectarDevelopmentData::tovGetPollenNectarCurvePtr

(

int

a_tov_ref

)

Uses the tov ref num to find the relevant curve set and return it as a pointer.

Definition at line 582 of file plants.cpp.

{
        PollenNectarDevelopmentCurveSet set;
        set.m_pollencurveptr = m_tolePollenCurves[0];;
        set.m_nectarcurveptr = m_toleNectarCurves[0];;
        set.m_pollencurveptr = m_tovPollenCurves[m_tov_pollencurvetable[ a_tov_ref ]];
        set.m_nectarcurveptr = m_tovNectarCurves[m_tov_pollencurvetable[a_tov_ref]];
        return set;
}

References PollenNectarDevelopmentCurveSet::m_nectarcurveptr, PollenNectarDevelopmentCurveSet::m_pollencurveptr, m_toleNectarCurves, m_tolePollenCurves, m_tov_pollencurvetable, m_tovNectarCurves, and m_tovPollenCurves.

Referenced by VegElement::SetVegType().

Member Data Documentation

m_tole_pollencurvetable

vector<int> PollenNectarDevelopmentData::m_tole_pollencurvetable

protected

Definition at line 243 of file plants.h.

Referenced by GetPollenNectarCurvePtr(), and PollenNectarDevelopmentData().

m_toleNectarCurves

vector<PollenNectarDevelopmentCurve*> PollenNectarDevelopmentData::m_toleNectarCurves

protected

Definition at line 241 of file plants.h.

Referenced by GetPollenNectarCurvePtr(), PollenNectarDevelopmentData(), tovGetPollenNectarCurvePtr(), and ~PollenNectarDevelopmentData().

m_tolePollenCurves

vector<PollenNectarDevelopmentCurve*> PollenNectarDevelopmentData::m_tolePollenCurves

protected

Definition at line 240 of file plants.h.

Referenced by GetPollenNectarCurvePtr(), PollenNectarDevelopmentData(), tovGetPollenNectarCurvePtr(), and ~PollenNectarDevelopmentData().

m_tov_pollencurvetable

vector<int> PollenNectarDevelopmentData::m_tov_pollencurvetable

protected

Definition at line 242 of file plants.h.

Referenced by PollenNectarDevelopmentData(), and tovGetPollenNectarCurvePtr().

m_tovNectarCurves

vector<PollenNectarDevelopmentCurve*> PollenNectarDevelopmentData::m_tovNectarCurves

protected

Definition at line 239 of file plants.h.

Referenced by PollenNectarDevelopmentData(), tovGetPollenNectarCurvePtr(), and ~PollenNectarDevelopmentData().

m_tovPollenCurves

vector<PollenNectarDevelopmentCurve*> PollenNectarDevelopmentData::m_tovPollenCurves

protected

Definition at line 238 of file plants.h.

Referenced by PollenNectarDevelopmentData(), tovGetPollenNectarCurvePtr(), and ~PollenNectarDevelopmentData().

---

The documentation for this class was generated from the following files:

• plants.h
• plants.cpp