#include <CFunctionAnalyzer.h>

Collaboration diagram for CFunctionAnalyzer::Result:

Classes
struct	FunctionInformation

Public Member Functions
void	clear ()

	Result ()

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

Public Attributes
FunctionInformation	mBPart

FunctionInformation	mFPart

bool	mIrreversibleKineticsWithProducts

FunctionInformation	mOriginalFunction

const CFunction *	mpFunction

bool	mReversibleNonSplitable

Detailed Description

This class contains the result of the analysis of one function.

Definition at line 141 of file CFunctionAnalyzer.h.

Constructor & Destructor Documentation

CFunctionAnalyzer::Result::Result ( )

Definition at line 403 of file CFunctionAnalyzer.cpp.

Referenced by clear().

   : mpFunction(NULL),
     mIrreversibleKineticsWithProducts(false),
     mReversibleNonSplitable(false)
 {};

Member Function Documentation

void CFunctionAnalyzer::Result::clear ( )

inline

Definition at line 166 of file CFunctionAnalyzer.h.

References Result().

Referenced by CFunctionAnalyzer::checkKineticFunction().

166 {*this = Result();};

CFunctionAnalyzer::Result::Result

Result()

Definition: CFunctionAnalyzer.cpp:403

bool CFunctionAnalyzer::Result::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 409 of file CFunctionAnalyzer.cpp.

References TriTrue, TriUnspecified, and CFunctionAnalyzer::write().

Referenced by CModelAnalyzer::ReactionResult::writeResult().

 {
   bool ret = false;
 
   if (!mpFunction) return false;
 
   //function name
   if (rt) os << "<h3>";
 
   os << mpFunction->getObjectName();
 
   if (rt) os << "</h3>";
 
   os << "\n";
 
   if (mIrreversibleKineticsWithProducts)
     {
       os << write(1, rt, "The kinetic function is marked as irreversible but at least one of its variables is labeled as product.\n", "");
       ret = true;
     }
 
   //interpret the CValues
   bool isReversible = (mpFunction->isReversible() == TriTrue);
 
   std::ostringstream tmpss;
     
   //only interprete the results if the kinetic law has specified reversibility.
   bool eee = true;
   if (mpFunction->isReversible() != TriUnspecified)
     eee = mOriginalFunction.writeAnalysis(tmpss, rt, isReversible);
 
   if (eee) ret = true;
 
   if (eee || verbose)
     {
       os << tmpss.str();
       mOriginalFunction.writeTable(os, rt);
     }
 
   //deal with splitted reversible functions
   if (mReversibleNonSplitable)
     {
       os << write(1, rt, "Copasi is not able to split the reversible kinetic function into two irreversible functions.\n", "");
       ret = true;
     }
   else if (isReversible)
     {
       std::ostringstream tmpss1;
       bool eee1 = mFPart.writeAnalysis(tmpss1, rt, false);
 
       std::ostringstream tmpss2;
       bool eee2 = mBPart.writeAnalysis(tmpss2, rt, false);
 
       if (eee1 || eee2) ret = true;
 
       if (eee1 || eee2 || verbose)
         {
           os << "The function was split into forward and backwards parts. Forward part:\n";
 
           if (rt) os << "<br>";
 
           os << tmpss1.str();
           mFPart.writeTable(os, rt);
           os << " Backwards part:\n";
 
           if (rt) os << "<br>";
 
           os << tmpss2.str();
           mBPart.writeTable(os, rt);
         }
     }
 
   return ret;
 }