#include <CModelAnalyzer.h>

Collaboration diagram for CModelAnalyzer::ReactionResult:

Public Member Functions
	ReactionResult ()

bool	writeResult (std::ostream &os, bool rt, bool verbose) const

Public Attributes
std::vector< std::string >	mChemEqMods

std::vector< std::string >	mChemEqProds

std::vector< std::string >	mChemEqSubs

std::vector< std::string >	mFunctionParametersMods

std::vector< std::string >	mFunctionParametersParams

std::vector< std::string >	mFunctionParametersProds

std::vector< std::string >	mFunctionParametersSubs

std::vector< std::string >	mFunctionParametersTime

std::vector< std::string >	mFunctionParametersVar

std::vector< std::string >	mFunctionParametersVol

CFunctionAnalyzer::Result	mFunctionResult

bool	mKineticUnspecifiedReversibility

std::vector< std::string >	mNotMetabolite

std::string	mReactionName

bool	mReversibilityMismatch

Detailed Description

Definition at line 33 of file CModelAnalyzer.h.

Constructor & Destructor Documentation

CModelAnalyzer::ReactionResult::ReactionResult ( )

inline

Definition at line 36 of file CModelAnalyzer.h.

             : mKineticUnspecifiedReversibility(false),
             mReversibilityMismatch(false)
         {}

Member Function Documentation

bool CModelAnalyzer::ReactionResult::writeResult	(	std::ostream &	os,
		bool	rt,
		bool	verbose
	)		const

writes a text report about the function to the stream. The return value indicates if a problem was reported.

Definition at line 343 of file CModelAnalyzer.cpp.

References mChemEqMods, mChemEqProds, mChemEqSubs, mFunctionParametersMods, mFunctionParametersParams, mFunctionParametersProds, mFunctionParametersSubs, mFunctionParametersTime, mFunctionParametersVar, mFunctionParametersVol, mFunctionResult, mKineticUnspecifiedReversibility, mNotMetabolite, mReactionName, mReversibilityMismatch, CFunctionAnalyzer::write(), and CFunctionAnalyzer::Result::writeResult().

 {
   bool ret = false;
 
   //reaction name
   if (rt) os << "<h2>";
 
   os << mReactionName;
 
   if (rt) os << "</h2>";
 
   os << "\n";
 
   //reaction results
   if (mKineticUnspecifiedReversibility)
     os << CFunctionAnalyzer::write(1, rt, "The kinetic function has unspecified reversibility.",
                                    "This means that checking the kinetic function will be less strict.");
 
   if (mReversibilityMismatch)
     os << CFunctionAnalyzer::write(3, rt, "The reversibility of the reaction and the kinetic function doesn't match.", "");
 
   size_t i, imax;
   imax = mChemEqSubs.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(2, rt, "The reaction substrate \""
                                      + mChemEqSubs[i]
                                      + "\" is not mapped to a corresponding function parameter.", "");
     }
 
   imax = mChemEqProds.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(2, rt, "The reaction product \""
                                      + mChemEqProds[i]
                                      + "\" is not mapped to a corresponding function parameter.", "");
     }
 
   imax = mChemEqMods.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(1, rt, "The reaction modifier \""
                                      + mChemEqMods[i]
                                      + "\" is not mapped to a corresponding function parameter.", "");
     }
 
   imax = mNotMetabolite.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(3, rt, "The function parameter \""
                                      + mNotMetabolite[i]
                                      + "\" which should be mapped to a metabolite is mapped to something else.", "");
     }
 
   imax = mFunctionParametersSubs.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(3, rt, "The function parameter \""
                                      + mFunctionParametersSubs[i]
                                      + "\" is not mapped to a substrate of the reaction.", "");
     }
 
   imax = mFunctionParametersProds.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(3, rt, "The function parameter \""
                                      + mFunctionParametersProds[i]
                                      + "\" is not mapped to a product of the reaction.", "");
     }
 
   imax = mFunctionParametersMods.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(3, rt, "The function parameter \""
                                      + mFunctionParametersMods[i]
                                      + "\" is not mapped to a modifier of the reaction.", "");
     }
 
   imax = mFunctionParametersParams.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(3, rt, "The function parameter \""
                                      + mFunctionParametersParams[i]
                                      + "\" is not mapped to local parameter or a global value.", "");
     }
 
   imax = mFunctionParametersVol.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(3, rt, "The function parameter \""
                                      + mFunctionParametersVol[i]
                                      + "\" is not mapped to a compartment.", "");
     }
 
   imax = mFunctionParametersTime.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(3, rt, "The function parameter \""
                                      + mFunctionParametersTime[i]
                                      + "\" is not correctly handled as model time.", "");
     }
 
   imax = mFunctionParametersVar.size();
 
   for (i = 0; i < imax; ++i)
     {
       os << CFunctionAnalyzer::write(1, rt, "The function parameter \""
                                      + mFunctionParametersVar[i]
                                      + "\" is marked as \"variable\". Not sure what this means.", "");
     }
 
   //function results
   std::ostringstream tmpss;
   bool eee = mFunctionResult.writeResult(tmpss, rt, verbose);
 
   if (eee) ret = true;
 
   if (eee || verbose)
     {
       os << tmpss.str();
     }
 
   return ret;
 }