CFunctionAnalyzer::Result::FunctionInformation Struct Reference

#include <CFunctionAnalyzer.h>

Collaboration diagram for CFunctionAnalyzer::Result::FunctionInformation:

Public Member Functions
bool	writeAnalysis (std::ostream &os, bool rt, bool reversible) const
void	writeTable (std::ostream &os, bool rt) const

Public Attributes
std::vector< std::pair < std::pair< size_t, std::string >, std::vector < CValue > > >	mProductZero
std::vector< std::pair < std::pair< size_t, std::string >, std::vector < CValue > > >	mSubstrateZero
std::vector< CValue >	mUnchangedParameters

Detailed Description

This contains low level information about one function. The Result class contains three instances of this structure: For the complete function and for the forward and backwards part of a reversible function

Definition at line 150 of file CFunctionAnalyzer.h.

Member Function Documentation

bool CFunctionAnalyzer::Result::FunctionInformation::writeAnalysis	(	std::ostream &	os,
		bool	rt,
		bool	reversible
	)		const

This writes a (hopefully) user understandable interpretation of the results to os. The return value indicates if a problem was reported.

Definition at line 484 of file CFunctionAnalyzer.cpp.

References CFunctionAnalyzer::write().

{
  bool ret = false;

  if (reversible) //reversible function
    {
      //unchanged values
      assert(mUnchangedParameters.size() >= 2);

      //first for positive parameter values
      if (!mUnchangedParameters[1].containsPositive())
        {
          os << write(1, rt, "The kinetic function cannot take positive values for positive parameter values.\n",
                      "This means the reaction will never proceed in the forward direction.");
          ret = true;
        }

      if (!mUnchangedParameters[1].containsZero())
        {
          os << write(1, rt, "The kinetic function never equals zero for positive parameter values.\n",
                      "This is unexpected for reversible reactions.");
          ret = true;
        }

      if (!mUnchangedParameters[1].containsNegative())
        {
          os << write(1, rt, "The kinetic function cannot take negative values for positive parameter values.\n",
                      "This means the reaction will never proceed in the backwards direction.");
          ret = true;
        }

      if (mUnchangedParameters[1].isInvalid())
        {
          os << write(2, rt, "The kinetic function is always invalid for positive parameter values.\n", "");
          ret = true;
        }
      else if (mUnchangedParameters[1].containsInvalid())
        {
          os << write(1, rt, "The kinetic function can be invalid even if metabolite concentrations and parameter values are positive.\n", "");
          ret = true;
        }

      //now report if the result is different for the actual parameters values
      if ((mUnchangedParameters.size() > 2) && (!(mUnchangedParameters[1] == mUnchangedParameters[2])))
        {
          if (!mUnchangedParameters[2].containsPositive())
            {
              os << write(1, rt, "The kinetic function cannot take positive values for the actual parameter values.\n",
                          "This means the reaction will never proceed in the forward direction.");
              ret = true;
            }

          if (!mUnchangedParameters[2].containsZero())
            {
              os << write(1, rt, "The kinetic function never equals zero for the actual parameter values.\n",
                          "This is unexpected for reversible reactions.");
              ret = true;
            }

          if (!mUnchangedParameters[2].containsNegative())
            {
              os << write(1, rt, "The kinetic function cannot take negative values for the actual parameter values.\n",
                          "This means the reaction will never proceed in the backwards direction.");
              ret = true;
            }

          if (mUnchangedParameters[2].isInvalid())
            {
              os << write(2, rt, "The kinetic function is always invalid for the actual parameter values.\n", "");
              ret = true;
            }
          else if (mUnchangedParameters[2].containsInvalid())
            {
              os << write(1, rt, "The kinetic function can be invalid for the actual parameter values even if metabolite concentrations are positive.\n", "");
              ret = true;
            }
        }

      size_t i, imax;

      // Substrate concentrations set to zero
      imax = mSubstrateZero.size();

      for (i = 0; i < imax; ++i)
        {
          assert(mSubstrateZero[i].second.size() >= 2);

          //first for positive parameter values
          if (mSubstrateZero[i].second[1].isNegative())
            {
              os << write(0, rt, "The kinetic function is always negative for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second //  pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" ,
                          "This is the expected behaviour for reversible reactions. Without substrates the reaction can only proceed backwards.");
            }
          else if (mSubstrateZero[i].second[1].containsNegative())
            {
              os << write(1, rt, "Copasi could not show that the kinetic function is always negative for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }
          else
            {
              os << write(2, rt, "The kinetic function is never negative for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" ,
                          "This means the reaction never proceeds backwards even if no substrate is present. This is unexpected for a reversible reaction.");
              ret = true;
            }

          if (mSubstrateZero[i].second[1].isInvalid())
            {
              os << write(2, rt, "The kinetic function is always invalid for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second  //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }
          else if (mSubstrateZero[i].second[1].containsInvalid())
            {
              os << write(1, rt, "The kinetic function can be invalid for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second //  pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }

          //now report if the result is different for the actual parameters values
          if ((mSubstrateZero[i].second.size() > 2) && (!(mSubstrateZero[i].second[1] == mSubstrateZero[i].second[2])))
            {
              if (mSubstrateZero[i].second[2].isNegative())
                {
                  os << write(0, rt, "The kinetic function is always negative for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //  pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" ,
                              "This is the expected behaviour for reversible reactions. Without substrates the reaction can only proceed backwards.");
                }
              else if (mSubstrateZero[i].second[2].containsNegative())
                {
                  os << write(1, rt, "Copasi could not show that the kinetic function is always negative for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }
              else
                {
                  os << write(2, rt, "The kinetic function is never negative for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" ,
                              "This means the reaction never proceeds backwards even if no substrate is present. This is unexpected for a reversible reaction.");
                  ret = true;
                }

              if (mSubstrateZero[i].second[2].isInvalid())
                {
                  os << write(2, rt, "The kinetic function is always invalid for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }
              else if (mSubstrateZero[i].second[2].containsInvalid())
                {
                  os << write(1, rt, "The kinetic function can be invalid for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }
            }
        } //loop over substrates that are set to zero

      // Product concentrations set to zero
      imax = mProductZero.size();

      for (i = 0; i < imax; ++i)
        {
          assert(mProductZero[i].second.size() >= 2);

          //first for positive parameter values
          if (mProductZero[i].second[1].isPositive())
            {
              os << write(0, rt, "The kinetic function is always positive for positive parameter values if product \""
                          + mProductZero[i].first.second //  pF->getVariables()[mProductZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" ,
                          "This is the expected behaviour for reversible reactions. With products absent the reaction can only proceed forward.");
            }
          else if (mProductZero[i].second[1].containsPositive())
            {
              os << write(1, rt, "Copasi could not show that the kinetic function is always positive for positive parameter values if product \""
                          + mProductZero[i].first.second //pF->getVariables()[mProductZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }
          else
            {
              os << write(2, rt, "The kinetic function is never positive for positive parameter values if product \""
                          + mProductZero[i].first.second //pF->getVariables()[mProductZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" ,
                          "This means the reaction never proceeds forward even if no product is present. This is unexpected for a reversible reaction.");
              ret = true;
            }

          if (mProductZero[i].second[1].isInvalid())
            {
              os << write(2, rt, "The kinetic function is always invalid for positive parameter values if product \""
                          + mProductZero[i].first.second  //pF->getVariables()[mProductZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }
          else if (mProductZero[i].second[1].containsInvalid())
            {
              os << write(1, rt, "The kinetic function can be invalid for positive parameter values if product \""
                          + mProductZero[i].first.second //  pF->getVariables()[mProductZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }

          //now report if the result is different for the actual parameters values
          if ((mProductZero[i].second.size() > 2) && (!(mProductZero[i].second[1] == mProductZero[i].second[2])))
            {
              if (mProductZero[i].second[2].isPositive())
                {
                  os << write(0, rt, "The kinetic function is always positive for the actual parameter values if product \""
                              + mProductZero[i].first.second //  pF->getVariables()[mProductZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" ,
                              "This is the expected behaviour for reversible reactions. With products absent the reaction can only proceed forward.");
                }
              else if (mProductZero[i].second[2].containsPositive())
                {
                  os << write(1, rt, "Copasi could not show that the kinetic function is always positive for the actual parameter values if product \""
                              + mProductZero[i].first.second //pF->getVariables()[mProductZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }
              else
                {
                  os << write(2, rt, "The kinetic function is never positive for the actual parameter values if product \""
                              + mProductZero[i].first.second //pF->getVariables()[mProductZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" ,
                              "This means the reaction never proceeds forward even if no product is present. This is unexpected for a reversible reaction.");
                  ret = true;
                }

              if (mProductZero[i].second[2].isInvalid())
                {
                  os << write(2, rt, "The kinetic function is always invalid for the actual parameter values if substrate \""
                              + mProductZero[i].first.second //pF->getVariables()[mProductZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }
              else if (mProductZero[i].second[2].containsInvalid())
                {
                  os << write(1, rt, "The kinetic function can be invalid for the actual parameter values if substrate \""
                              + mProductZero[i].first.second //pF->getVariables()[mProductZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }
            }
        } //loop over products that are set to zero
    }
  else //irreversible function
    {
      //unchanged values
      assert(mUnchangedParameters.size() >= 2);

      //first for positive parameter values
      if (mUnchangedParameters[1].isPositive())
        {
          os << write(0, rt, "The kinetic function is positive for positive parameter values.\n", "");
        }
      else
        {
          os << write(1, rt, "Copasi could not show that the kinetic function is positive for positive parameter values.\n", "");
          ret = true;
        }

      if (mUnchangedParameters[1].isZero())
        {
          os << write(2, rt, "The kinetic function is always zero for positive parameter values.\n", "");
          ret = true;
        }
      else if (mUnchangedParameters[1].containsZero())
        {
          os << write(1, rt, "The kinetic function can be zero even if substrate concentrations and parameter values are positive.\n", "");
          ret = true;
        }

      if (mUnchangedParameters[1].isNegative())
        {
          os << write(2, rt, "The kinetic function is always negative for positive parameter values.\n", "");
          ret = true;
        }
      else if (mUnchangedParameters[1].containsNegative())
        {
          os << write(1, rt, "The kinetic function can be negative even if substrate concentrations and parameter values are positive.\n", "");
          ret = true;
        }

      if (mUnchangedParameters[1].isInvalid())
        {
          os << write(2, rt, "The kinetic function is always invalid for positive parameter values.\n", "");
          ret = true;
        }
      else if (mUnchangedParameters[1].containsInvalid())
        {
          os << write(1, rt, "The kinetic function can be invalid even if substrate concentrations and parameter values are positive.\n", "");
          ret = true;
        }

      //now report if the result is different for the actual parameters values
      if ((mUnchangedParameters.size() > 2) && (!(mUnchangedParameters[1] == mUnchangedParameters[2])))
        {
          if (mUnchangedParameters[2].isPositive())
            {
              os << write(0, rt, "The kinetic function is positive for the actual parameter values.\n", "");
            }
          else
            {
              os << write(1, rt, "Copasi could not show that the kinetic function is positive for the actual parameter values.\n", "");
              ret = true;
            }

          if (mUnchangedParameters[2].isZero())
            {
              os << write(2, rt, "The kinetic function is always zero for the actual parameter values.\n", "");
              ret = true;
            }
          else if (mUnchangedParameters[2].containsZero())
            {
              os << write(1, rt, "The kinetic function can be zero for the actual parameter values even if substrate concentrations are positive.\n", "");
              ret = true;
            }

          if (mUnchangedParameters[2].isNegative())
            {
              os << write(2, rt, "The kinetic function is always negative for the actual parameter values.\n", "");
              ret = true;
            }
          else if (mUnchangedParameters[2].containsNegative())
            {
              os << write(1, rt, "The kinetic function can be negative for the actual parameter values even if substrate concentrations are positive.\n", "");
              ret = true;
            }

          if (mUnchangedParameters[2].isInvalid())
            {
              os << write(2, rt, "The kinetic function is always invalid for the actual parameter values.\n", "");
              ret = true;
            }
          else if (mUnchangedParameters[2].containsInvalid())
            {
              os << write(1, rt, "The kinetic function can be invalid for the actual parameter values even if substrate concentrations are positive.\n", "");
              ret = true;
            }
        }

      size_t i, imax;

      // Substrate concentrations set to zero
      imax = mSubstrateZero.size();

      for (i = 0; i < imax; ++i)
        {
          assert(mSubstrateZero[i].second.size() >= 2);

          //first for positive parameter values
          if (mSubstrateZero[i].second[1].isZero())
            {
              os << write(0, rt, "The kinetic function is always zero for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second //  pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
            }
          else if (mSubstrateZero[i].second[1].containsZero())
            {
              os << write(1, rt, "Copasi could not show that the kinetic function is always zero for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }
          else
            {
              os << write(2, rt, "The kinetic function is never zero for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }

          if (mSubstrateZero[i].second[1].isInvalid())
            {
              os << write(2, rt, "The kinetic function is always invalid for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second  //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }
          else if (mSubstrateZero[i].second[1].containsInvalid())
            {
              os << write(1, rt, "The kinetic function can be invalid for positive parameter values if substrate \""
                          + mSubstrateZero[i].first.second //  pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                          + "\" is set to zero.\n" , "");
              ret = true;
            }

          //now report if the result is different for the actual parameters values
          if ((mSubstrateZero[i].second.size() > 2) && (!(mSubstrateZero[i].second[1] == mSubstrateZero[i].second[2])))
            {
              if (mSubstrateZero[i].second[2].isZero())
                {
                  os << write(0, rt, "The kinetic function is always zero for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                }
              else if (mSubstrateZero[i].second[2].containsZero())
                {
                  os << write(1, rt, "Copasi could not show that the kinetic function is always zero for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }
              else
                {
                  os << write(2, rt, "The kinetic function is never zero for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }

              if (mSubstrateZero[i].second[2].isInvalid())
                {
                  os << write(2, rt, "The kinetic function is always invalid for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }
              else if (mSubstrateZero[i].second[2].containsInvalid())
                {
                  os << write(1, rt, "The kinetic function can be invalid for the actual parameter values if substrate \""
                              + mSubstrateZero[i].first.second //pF->getVariables()[mSubstrateZero[i].first]->getObjectName()
                              + "\" is set to zero.\n" , "");
                  ret = true;
                }
            }
        } //loop over substrates that are set to zero
    } //irreversible

  //mUnchangedParameters
  //mSubstrateZero
  //mProductZero

  return ret;
}

void CFunctionAnalyzer::Result::FunctionInformation::writeTable	(	std::ostream &	os,
		bool	rt
	)		const

Definition at line 933 of file CFunctionAnalyzer.cpp.

{
  //if (!pF) return;

  size_t i, imax;

  if (rt)
    {
      os << "<font color=\"#505080\"><TABLE>\n";

      os << "  <TR>\n";
      os << "    <TD></TD>\n";
      //CValue results
      size_t j, jmax = mUnchangedParameters.size();

      for (j = 0; j < jmax; ++j)
        os << "    <TD>" << mUnchangedParameters[j] << "</TD>\n";

      os << "  </TR>\n";

      imax = mSubstrateZero.size();

      for (i = 0; i < imax; ++i)
        {
          os << "  <TR>\n";
          //parameter name
          os << "    <TD>Substrate \"" << mSubstrateZero[i].first.second /*pF->getVariables()[mSubstrateZero[i].first]->getObjectName()*/ << "\" set to 0:</TD>\n";

          //CValue results
          size_t j, jmax = mSubstrateZero[i].second.size();

          for (j = 0; j < jmax; ++j)
            os << "    <TD>" << mSubstrateZero[i].second[j] << "</TD>\n";

          os << "  </TR>\n";
        }

      imax = mProductZero.size();

      for (i = 0; i < imax; ++i)
        {
          os << "  <TR>\n";
          //parameter name
          os << "    <TD>Product \"" << mProductZero[i].first.second << "\" set to 0: </TD>\n";

          //CValue results
          size_t j, jmax = mProductZero[i].second.size();

          for (j = 0; j < jmax; ++j)
            os << "    <TD>" << mProductZero[i].second[j] << "</TD>\n";

          os << "  </TR>\n";
        }

      os << "</TABLE></font>\n";
    }
}

Member Data Documentation

std::vector<std::pair<std::pair<size_t, std::string>, std::vector<CValue> > > CFunctionAnalyzer::Result::FunctionInformation::mProductZero

Definition at line 154 of file CFunctionAnalyzer.h.

Referenced by CFunctionAnalyzer::checkKineticFunction().

std::vector<std::pair<std::pair<size_t, std::string>, std::vector<CValue> > > CFunctionAnalyzer::Result::FunctionInformation::mSubstrateZero

Definition at line 153 of file CFunctionAnalyzer.h.

Referenced by CFunctionAnalyzer::checkKineticFunction().

std::vector<CValue> CFunctionAnalyzer::Result::FunctionInformation::mUnchangedParameters

Definition at line 152 of file CFunctionAnalyzer.h.

Referenced by CFunctionAnalyzer::checkKineticFunction().

---

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

• CFunctionAnalyzer.h
• CFunctionAnalyzer.cpp