CMCAMethod.h

Go to the documentation of this file.

// Copyright (C) 2010 - 2015 by Pedro Mendes, Virginia Tech Intellectual
// Properties, Inc., University of Heidelberg, and The University
// of Manchester.
// All rights reserved.

// Copyright (C) 2008 - 2009 by Pedro Mendes, Virginia Tech Intellectual
// Properties, Inc., EML Research, gGmbH, University of Heidelberg,
// and The University of Manchester.
// All rights reserved.

// Copyright (C) 2004 - 2007 by Pedro Mendes, Virginia Tech Intellectual
// Properties, Inc. and EML Research, gGmbH.
// All rights reserved.

#ifndef COPASI_CMCAMethod_H__
#define COPASI_CMCAMethod_H__

#include <vector>
#include "utilities/CLinkMatrix.h"
#include "utilities/CCopasiMethod.h"
#include "utilities/CAnnotatedMatrix.h"
#include "steadystate/CSteadyStateMethod.h"

class CModel;
class CSteadyStateTask;

class CMCAMethod: public CCopasiMethod
{
public:
  /**
   * Create a MCA method.
   * Note: the returned object has to be released after use with delete
   */
  static CMCAMethod * createMethod(CCopasiMethod::SubType subType = CCopasiMethod::mcaMethodReder);

  /**
   * Default constructor
   * @param const CCopasiContainer * pParent (Default: NULL)
   */
  CMCAMethod(const CCopasiContainer * pParent = NULL);

  /**
   * Copy constructor
   * @param const CMCAMethod & src
   * @param const CCopasiContainer * pParent (Default: NULL)
   */
  CMCAMethod(const CMCAMethod & src,
             const CCopasiContainer * pParent = NULL);

  /**
   * Destructor
   */
  virtual ~CMCAMethod();

  /**
   * This methods must be called to elevate subgroups to
   * derived objects. The default implementation does nothing.
   * @return bool success
   */
  virtual bool elevateChildren();

  const CMatrix<C_FLOAT64> & getUnscaledElasticities() const
  {return mUnscaledElasticities;}

  void calculateUnscaledElasticities(C_FLOAT64 res);

  const CMatrix<C_FLOAT64> & getUnscaledConcentrationCC() const
  {return mUnscaledConcCC;}

  bool calculateUnscaledConcentrationCC();

  const CMatrix<C_FLOAT64> & getUnscaledFluxCC() const
  {return mUnscaledFluxCC;}

  bool calculateUnscaledFluxCC(const bool & status);

  const CMatrix<C_FLOAT64> & getScaledElasticities() const
  {return mScaledElasticities;}

  const CMatrix<C_FLOAT64> & getScaledConcentrationCC() const
  {return mScaledConcCC;}

  const CMatrix<C_FLOAT64> & getScaledFluxCC() const
  {return mScaledFluxCC;}

  const CArrayAnnotation* getUnscaledElasticitiesAnn() const
  {return mUnscaledElasticitiesAnn;}
  const CArrayAnnotation* getScaledElasticitiesAnn() const
  {return mScaledElasticitiesAnn;}
  const CArrayAnnotation* getUnscaledConcentrationCCAnn() const
  {return mUnscaledConcCCAnn;}
  const CArrayAnnotation* getScaledConcentrationCCAnn() const
  {return mScaledConcCCAnn;}
  const CArrayAnnotation* getUnscaledFluxCCAnn() const
  {return mUnscaledFluxCCAnn;}
  const CArrayAnnotation* getScaledFluxCCAnn() const
  {return mScaledFluxCCAnn;}

  /**
   * Resizes all result matrices and updates the corresponding array annotations.
   * This needs to be called before output initialization (in case the output references
   * parts of the matrix) from the task initialization, but it also needs to be called
   * before selecting elements of the matrices in the object selection dialog.
   * The model needs to be set before calling this.
   */
  virtual void resizeAllMatrices();

  /**
   * Scales the coefficients (i.e. Kacser format, rather than Reder)
   */
  bool scaleMCA(const bool & status, C_FLOAT64 res);

  /**
   * Check whether the summation theorems hold.
   */
  bool checkSummationTheorems(const C_FLOAT64 & resolution);

  /**
   * Set the Model
   */
  void setModel(CModel* model);

  /**
   * Get the Model
   */
  const CModel* getModel() const;

  /**
   * the steady state MCA entry point
   * @param ss_solution refer to steady-state solution
   * @param refer to the resolution
   */
  bool CalculateMCA(C_FLOAT64 res);

  /**
   *
   */
  virtual bool process();

  /**
   * Read SSMCAUnscaled from configuration file
   */
  C_INT32 load(CReadConfig & configBuffer);

  void setSteadyStateTask(CSteadyStateTask * pSteadyStateTask);

  const CSteadyStateMethod::ReturnCode & getSteadyStateStatus() const
  {return mSSStatus;}

  void setFactor(C_FLOAT64 factor);

  void setSteadyStateResolution(C_FLOAT64 factor);

  /**
   * Check if the method is suitable for this problem
   * @return bool suitability of the method
   */
  virtual bool isValidProblem(const CCopasiProblem * pProblem);

private:
  void initObjects();

  /**
   * Initialize the method parameter
   */
  void initializeParameter();

  bool createLinkMatrix(const bool & useSmallbone = false);

private:

  CModel * mpModel;

  bool * mpUseReeder;

  bool * mpUseSmallbone;

  /**
   * MCA Matrices
   */
  CMatrix<C_FLOAT64> mUnscaledElasticities;
  CArrayAnnotation* mUnscaledElasticitiesAnn;

  CMatrix<C_FLOAT64> mUnscaledConcCC;
  CArrayAnnotation* mUnscaledConcCCAnn;

  CMatrix<C_FLOAT64> mUnscaledFluxCC;
  CArrayAnnotation* mUnscaledFluxCCAnn;

  CMatrix<C_FLOAT64> mScaledElasticities;
  CArrayAnnotation* mScaledElasticitiesAnn;

  CMatrix<C_FLOAT64> mScaledConcCC;
  CArrayAnnotation* mScaledConcCCAnn;

  CMatrix<C_FLOAT64> mScaledFluxCC;
  CArrayAnnotation* mScaledFluxCCAnn;

  /**
   * 1 if MCA coeffs are to be unscaled
   */
  C_INT16 mSSReder;

  /**
   * If need to evaluate the elasticities, ss_x
   * will be assigned in calculateTimeMCA()
   */
  std::vector <C_FLOAT64> mSsx;

  /**
   * Modulation factor for finite differences derivation
   */
  C_FLOAT64 mFactor;

  C_FLOAT64 mSteadyStateResolution;

  CSteadyStateMethod::ReturnCode mSSStatus;

  CSteadyStateTask * mpSteadyStateTask;

  CLinkMatrix mLinkZero;

  CMatrix< C_FLOAT64 > mReducedStoichiometry;

  CMatrix< bool > mElasticityDependencies;
};
#endif // COPASI_CMca