thermal_time_senescence.h

Go to the documentation of this file.

#ifndef THERMAL_TIME_SENESCENCE_H
#define THERMAL_TIME_SENESCENCE_H
 
#include "../framework/module.h"
#include "../framework/state_map.h"
 
namespace standardBML
{
class thermal_time_senescence : public differential_module
{
   public:
    thermal_time_senescence(
        state_map const& input_quantities,
        state_map* output_quantities)
        :  // Indicate that this module requires a fixed step size Euler ODE solver
          differential_module(true),
 
          // Get pointers to input quantities
          TTc{get_input(input_quantities, "TTc")},
          seneLeaf{get_input(input_quantities, "seneLeaf")},
          seneStem{get_input(input_quantities, "seneStem")},
          seneRoot{get_input(input_quantities, "seneRoot")},
          seneRhizome{get_input(input_quantities, "seneRhizome")},
          leaf_senescence_index{get_input(input_quantities, "leaf_senescence_index")},
          stem_senescence_index{get_input(input_quantities, "stem_senescence_index")},
          root_senescence_index{get_input(input_quantities, "root_senescence_index")},
          rhizome_senescence_index{get_input(input_quantities, "rhizome_senescence_index")},
          kStem{get_input(input_quantities, "kStem")},
          kRoot{get_input(input_quantities, "kRoot")},
          kRhizome{get_input(input_quantities, "kRhizome")},
          kGrain{get_input(input_quantities, "kGrain")},
          remobilization_fraction{get_input(input_quantities, "remobilization_fraction")},
          net_assimilation_rate_leaf{get_input(input_quantities, "net_assimilation_rate_leaf")},
          net_assimilation_rate_stem{get_input(input_quantities, "net_assimilation_rate_stem")},
          net_assimilation_rate_root{get_input(input_quantities, "net_assimilation_rate_root")},
          net_assimilation_rate_rhizome{get_input(input_quantities, "net_assimilation_rate_rhizome")},
 
          // Get pointers to output quantities
          Leaf_op{get_op(output_quantities, "Leaf")},
          LeafLitter_op{get_op(output_quantities, "LeafLitter")},
          leaf_senescence_index_op{get_op(output_quantities, "leaf_senescence_index")},
          Stem_op{get_op(output_quantities, "Stem")},
          StemLitter_op{get_op(output_quantities, "StemLitter")},
          stem_senescence_index_op{get_op(output_quantities, "stem_senescence_index")},
          Root_op{get_op(output_quantities, "Root")},
          RootLitter_op{get_op(output_quantities, "RootLitter")},
          root_senescence_index_op{get_op(output_quantities, "root_senescence_index")},
          Rhizome_op{get_op(output_quantities, "Rhizome")},
          RhizomeLitter_op{get_op(output_quantities, "RhizomeLitter")},
          rhizome_senescence_index_op{get_op(output_quantities, "rhizome_senescence_index")},
          Grain_op{get_op(output_quantities, "Grain")}
    {
    }
    static string_vector get_inputs();
    static string_vector get_outputs();
    static std::string get_name() { return "thermal_time_senescence"; }
 
   private:
    // Vectors for storing information about growth history
    //  Note: this feature is peculiar to this module
    //   and should be avoided in general since it
    //   precludes the use of any integration method
    //   except fixed-step Euler
    std::vector<double> mutable assim_rate_leaf_vec;
    std::vector<double> mutable assim_rate_stem_vec;
    std::vector<double> mutable assim_rate_root_vec;
    std::vector<double> mutable assim_rate_rhizome_vec;
 
    // Pointers to input quantities
    double const& TTc;
    double const& seneLeaf;
    double const& seneStem;
    double const& seneRoot;
    double const& seneRhizome;
    double const& leaf_senescence_index;
    double const& stem_senescence_index;
    double const& root_senescence_index;
    double const& rhizome_senescence_index;
    double const& kStem;
    double const& kRoot;
    double const& kRhizome;
    double const& kGrain;
    const double& remobilization_fraction;
    double const& net_assimilation_rate_leaf;
    double const& net_assimilation_rate_stem;
    double const& net_assimilation_rate_root;
    double const& net_assimilation_rate_rhizome;
 
    // Pointers to output quantities
    double* Leaf_op;
    double* LeafLitter_op;
    double* leaf_senescence_index_op;
    double* Stem_op;
    double* StemLitter_op;
    double* stem_senescence_index_op;
    double* Root_op;
    double* RootLitter_op;
    double* root_senescence_index_op;
    double* Rhizome_op;
    double* RhizomeLitter_op;
    double* rhizome_senescence_index_op;
    double* Grain_op;
 
    // Main operation
    void do_operation() const;
};
 
string_vector thermal_time_senescence::get_inputs()
{
    return {
        "TTc",                           // degree C * day
        "seneLeaf",                      // degree C * day
        "seneStem",                      // degree C * day
        "seneRoot",                      // degree C * day
        "seneRhizome",                   // degree C * day
        "leaf_senescence_index",         // dimensionless
        "stem_senescence_index",         // dimensionless
        "root_senescence_index",         // dimensionless
        "rhizome_senescence_index",      // dimensionless
        "kStem",                         // dimensionless
        "kRoot",                         // dimensionless
        "kRhizome",                      // dimensionless
        "kGrain",                        // dimensionless
        "remobilization_fraction",       // dimensionless
        "net_assimilation_rate_leaf",    // Mg / ha / hour
        "net_assimilation_rate_stem",    // Mg / ha / hour
        "net_assimilation_rate_root",    // Mg / ha / hour
        "net_assimilation_rate_rhizome"  // Mg / ha / hour
    };
}
 
string_vector thermal_time_senescence::get_outputs()
{
    return {
        "Leaf",                      // Mg / ha / hour
        "LeafLitter",                // Mg / ha / hour
        "leaf_senescence_index",     // hour^-1
        "Stem",                      // Mg / ha / hour
        "StemLitter",                // Mg / ha / hour
        "stem_senescence_index",     // hour^-1
        "Root",                      // Mg / ha / hour
        "RootLitter",                // Mg / ha / hour
        "root_senescence_index",     // hour^-1
        "Rhizome",                   // Mg / ha / hour
        "RhizomeLitter",             // Mg / ha / hour
        "rhizome_senescence_index",  // hour^-1
        "Grain"                      // Mg / ha / hour
    };
}
 
void thermal_time_senescence::do_operation() const
{
    // Add the new tissue growth to the history vectors
    assim_rate_leaf_vec.push_back(net_assimilation_rate_leaf);
    assim_rate_stem_vec.push_back(net_assimilation_rate_stem);
    assim_rate_root_vec.push_back(net_assimilation_rate_root);
    assim_rate_rhizome_vec.push_back(net_assimilation_rate_rhizome);
 
    // Initialize variables
    double dLeaf{0.0};
    double dStem{0.0};
    double dRoot{0.0};
    double dRhizome{0.0};
    double dGrain{0.0};
    double dLeafLitter{0.0};
    double dStemLitter{0.0};
    double dRootLitter{0.0};
    double dRhizomeLitter{0.0};
    double dleaf_senescence_index{0.0};
    double dstem_senescence_index{0.0};
    double droot_senescence_index{0.0};
    double drhizome_senescence_index{0.0};
 
    if (TTc >= seneLeaf) {
        // Look back in time to find out how much the tissue grew in the past
        double change = assim_rate_leaf_vec.at(leaf_senescence_index);
 
        // Subtract the rate of new growth that occurred in the past from the
        // derivative
        dLeaf -= change;
 
        // Remobilize some of the lost tissue and send the rest to the litter
        dLeafLitter += change * (1.0 - remobilization_fraction);
        dRhizome += kRhizome * change * remobilization_fraction;
        dStem += kStem * change * remobilization_fraction;
        dRoot += kRoot * change * remobilization_fraction;
        dGrain += kGrain * change * remobilization_fraction;
 
        // Increment the tissue senescence index
        dleaf_senescence_index++;
    }
 
    if (TTc >= seneStem) {
        // Look back in time to find out how much the tissue grew in the past
        double change = assim_rate_stem_vec.at(stem_senescence_index);
 
        // Subtract the rate of new growth that occurred in the past from the
        // derivative
        dStem -= change;
 
        // Send the lost tissue to the litter
        dStemLitter += change;
 
        // Increment the tissue senescence index
        dstem_senescence_index++;
    }
 
    if (TTc >= seneRoot) {
        // Look back in time to find out how much the tissue grew in the past
        double change = assim_rate_root_vec.at(root_senescence_index);
 
        // Subtract the rate of new growth that occurred in the past from the
        // derivative
        dRoot -= change;
 
        // Send the lost tissue to the litter
        dRootLitter += change;
 
        // Increment the tissue senescence index
        droot_senescence_index++;
    }
 
    if (kRhizome < 0) {
        // Increment the rhizome senescence index if it is acting as a source
        drhizome_senescence_index++;
    }
 
    if (TTc >= seneRhizome) {
        // Look back in time to find out how much the tissue grew in the past
        double change = assim_rate_rhizome_vec.at(rhizome_senescence_index);
 
        // Subtract the rate of new growth that occurred in the past from the
        // derivative
        dRhizome -= change;
 
        // Send the lost tissue to the litter
        dRhizomeLitter += change;
 
        // Increment the tissue senescence index
        drhizome_senescence_index++;
    }
 
    // Update the output quantity list
    update(Leaf_op, dLeaf);
    update(Stem_op, dStem);
    update(Root_op, dRoot);
    update(Rhizome_op, dRhizome);
    update(Grain_op, dGrain);
 
    update(LeafLitter_op, dLeafLitter);
    update(StemLitter_op, dStemLitter);
    update(RootLitter_op, dRootLitter);
    update(RhizomeLitter_op, dRhizomeLitter);
 
    update(leaf_senescence_index_op, dleaf_senescence_index);
    update(stem_senescence_index_op, dstem_senescence_index);
    update(root_senescence_index_op, droot_senescence_index);
    update(rhizome_senescence_index_op, drhizome_senescence_index);
}
 
}  // namespace standardBML
#endif