CAnnotatedMatrix.cpp

Go to the documentation of this file.

// Begin CVS Header
//   $Source: /Volumes/Home/Users/shoops/cvs/copasi_dev/copasi/utilities/CAnnotatedMatrix.cpp,v $
//   $Revision: 1.37 $
//   $Name:  $
//   $Author: shoops $
//   $Date: 2012/04/20 12:08:24 $
// End CVS Header

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

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

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

/*!
    \file CAnnotatedMatrix.cpp
    \brief Implementation file of class CCopasiArray and CArrayAnnotation
 */

#include <sstream>
#include "CAnnotatedMatrix.h"
#include "CCopasiVector.h"

#include "report/CKeyFactory.h"
#include "report/CArrayElementReference.h"
#include "CopasiDataModel/CCopasiDataModel.h"

CArrayAnnotation::CArrayAnnotation(const std::string & name,
                                   const CCopasiContainer * pParent,
                                   CCopasiAbstractArray * array,
                                   const bool & adopt)
    : CCopasiContainer(name, pParent, "Array" , CCopasiObject::Array),
    mpArray(array),
    mDestructArray(adopt),
    mDefaultMode(OBJECTS)
{
  assert(mpArray);

  resize();

  //addObjectReference("Annotated Matrix", *this, CCopasiObject::ValueDbl);
}

CArrayAnnotation::~CArrayAnnotation()
{
  if (mDestructArray)
    pdelete(mpArray);
}

void CArrayAnnotation::setArray(CCopasiAbstractArray * a)
{
  mpArray = a;
}

void CArrayAnnotation::setMode(size_t d, Mode m)
{
  mModes[d] = m;
  resizeOneDimension(d);
}

void CArrayAnnotation::setMode(Mode m)
{
  mDefaultMode = m;

  size_t i;

  for (i = 0; i < mModes.size(); ++i)
    setMode(i, m);
}

size_t CArrayAnnotation::dimensionality() const
{
  return mModes.size();
}

void CArrayAnnotation::setCopasiVector(size_t d, const CCopasiContainer* v)
{
  assert(d < mCopasiVectors.size());
  assert((mModes[d] == VECTOR) || (mModes[d] == VECTOR_ON_THE_FLY));

  mCopasiVectors[d] = v;

  if (mModes[d] == VECTOR)
    createAnnotationsCNFromCopasiVector(d, mCopasiVectors[d]);
}

void CArrayAnnotation::setAnnotationCN(size_t d, size_t i, const std::string cn)
{
  assert(d < mAnnotationsCN.size());
  assert(mModes[d] == OBJECTS);

  resizeOneDimension(d);
  assert(i < mAnnotationsCN[d].size());

  mAnnotationsCN[d][i] = cn;
}

void CArrayAnnotation::setAnnotationString(size_t d, size_t i, const std::string s)
{
  assert(d < mAnnotationsString.size());
  assert(mModes[d] == STRINGS);

  resizeOneDimension(d);
  assert(i < mAnnotationsString[d].size());

  mAnnotationsString[d][i] = s;
}

const std::vector<CRegisteredObjectName> & CArrayAnnotation::getAnnotationsCN(size_t d) const
{
  assert(d < mModes.size());
  assert(mModes[d] != STRINGS);
  assert(mModes[d] != NUMBERS);

  if (mModes[d] == VECTOR_ON_THE_FLY)
    createAnnotationsCNFromCopasiVector(d, mCopasiVectors[d]);

  return mAnnotationsCN[d];
}

const std::vector<std::string> & CArrayAnnotation::getAnnotationsString(size_t d, bool display) const
{
  assert(d < mModes.size());

  //generate CNs (if necessary)
  if (mModes[d] == VECTOR_ON_THE_FLY)
    createAnnotationsCNFromCopasiVector(d, mCopasiVectors[d]);

  //generate DisplayNames
  if ((mModes[d] == VECTOR) || (mModes[d] == VECTOR_ON_THE_FLY) || (mModes[d] == OBJECTS))
    {
      size_t i, imax = mAnnotationsCN[d].size();
      mAnnotationsString[d].resize(imax);
      const CCopasiDataModel* pDataModel = getObjectDataModel();
      assert(pDataModel != NULL);

      for (i = 0; i < imax; ++i)
        {
          const CCopasiObject * obj = pDataModel->getDataObject(mAnnotationsCN[d][i]);

          if (obj)
            mAnnotationsString[d][i] =
              display ? obj->getObjectDisplayName() : obj->getObjectName();
          else
            mAnnotationsString[d][i] = "???";
        }
    }

  //generate Numbers
  if (mModes[d] == NUMBERS)
    createNumbers(d);

  // if the mode is STRINGS do nothing, mAnnotationsString is supposed to contain
  // the correct strings

  return mAnnotationsString[d];
}

const std::string & CArrayAnnotation::getDimensionDescription(size_t d) const
{
  assert(d < mDimensionDescriptions.size());
  return mDimensionDescriptions[d];
}

void CArrayAnnotation::setDimensionDescription(size_t d, const std::string & s)
{
  assert(d < mDimensionDescriptions.size());
  mDimensionDescriptions[d] = s;
}

const std::string & CArrayAnnotation::getDescription() const
{return mDescription;}

void CArrayAnnotation::setDescription(const std::string & s)
{mDescription = s;}

bool CArrayAnnotation::createAnnotationsCNFromCopasiVector(size_t d,
    const CCopasiContainer* v) const
{
  if (!v) return false;

  if (!(v->isVector() || v->isNameVector())) return false;

  if (d >= mpArray->dimensionality()) return false;

  //now we know we have a vector. A CCopasiVector[N/S], hopefully, so that the following cast is valid:
  const CCopasiVector< CCopasiObject > * pVector =
    reinterpret_cast<const CCopasiVector< CCopasiObject > * >(v);

  mAnnotationsCN[d].resize(pVector->size());
  //if (pVector->size() < mAnnotations[d].size()) return false;

  size_t i;

  for (i = 0; i < mAnnotationsCN[d].size(); ++i)
    {
      if (!(*pVector)[i])
        return false;
      else
        mAnnotationsCN[d][i] = (*pVector)[i]->getCN();
    }

  return true;
}

//private
void CArrayAnnotation::createNumbers(size_t /*d*/) const
{
  //TODO
}

//private
void CArrayAnnotation::reDimensionalize(size_t d)
{
  mAnnotationsCN.resize(d);
  mAnnotationsString.resize(d);
  mDimensionDescriptions.resize(d);
  mCopasiVectors.resize(d);
  mModes.resize(d, mDefaultMode);
}

//private
void CArrayAnnotation::resizeOneDimension(size_t d)
{
  if (mModes[d] != VECTOR)
    {
      mAnnotationsCN[d].resize(mpArray->size()[d]);
      mAnnotationsString[d].resize(mpArray->size()[d]);
    }
}

void CArrayAnnotation::resize()
{
  assert(mpArray);
  reDimensionalize(mpArray->dimensionality());

  size_t i, imax = mpArray->dimensionality();

  for (i = 0; i < imax; ++i)
    resizeOneDimension(i);
}

const CObjectInterface * CArrayAnnotation::addElementReference(CCopasiAbstractArray::index_type index) const
{
  //generate the index string
  std::string tmp;
  std::ostringstream indexString;
  size_t ii = 0;

  for (ii = 0; ii < index.size(); ++ii)
    {
      indexString << "[" << index[ii] << "]";
    }

  //handle zero-dimensional arrays
  if (index.size() == 0)
    indexString << "[.]";

  return this->getObject(indexString.str());
}

const CObjectInterface * CArrayAnnotation::addElementReference(C_INT32 u, C_INT32 v) const
{
  CCopasiAbstractArray::index_type index;
  index.push_back(u);
  index.push_back(v);
  return addElementReference(index);
}

const CObjectInterface * CArrayAnnotation::addElementReference(C_INT32 u) const
{
  CCopasiAbstractArray::index_type index;
  index.push_back(u);
  return addElementReference(index);
}

void CArrayAnnotation::appendElementReferences(std::set< const CCopasiObject * > & objects) const
{
  objectMap::const_iterator it = mObjects.begin();
  objectMap::const_iterator end = mObjects.end();

  for (; it != end; ++it)
    if (dynamic_cast<const CArrayElementReference *>(it->second) != NULL)
      objects.insert(it->second);

  return;
}

const CObjectInterface * CArrayAnnotation::getObject(const CCopasiObjectName & cn) const
{
  if (cn == "")
    {
      return this;
    }

  if (cn == "Property=DisplayName")
    {
      return CCopasiObject::getObject(cn);
    }

  //if there are no indices there could still be other children. This can be handled
  //by the container base class
  if (cn.getElementName(0, false) == "") //no indices
    return this->CCopasiContainer::getObject(cn);

  //so now we know we have indices. So we check if the array element reference
  //exists, if not we create it. Then getObject() of the element reference is called
  //with the remainder TODO

  /*
      //first get the array indices. At the moment only numerical indices...
      C_INT32 ii = 0;
      CCopasiArray::index_type index;
      while (cn.getElementName(ii, false) != "")
        {
          index.push_back(cn.getElementIndex(ii));
          ++ii;
        }
  */

  //first get the index string
  std::string tmp;
  std::string indexString;
  C_INT32 ii = 0;

  while ((tmp = cn.getElementName(ii, false)) != "")
    {
      indexString += "[" + tmp + "]";
      ++ii;
    }

  const CCopasiObject* pObject = NULL; //this will contain the element reference

  //if the reference object already exists, its name will be identical to the index
  std::pair< objectMap::const_iterator, objectMap::const_iterator > range =
    mObjects.equal_range(indexString);

  objectMap::const_iterator it = range.first;

  while (it != range.second && it->second->getObjectType() != "ElementReference") ++it;

  if (it == range.second) //not found
    {
      //create new element reference
      pObject = new CArrayElementReference(cn, this);
    }
  else
    {
      pObject = it->second;
    }

  if (pObject)
    return pObject->getObject(cn.getRemainder());
  else
    return NULL;

  /*
  if (index.size() != dimensionality())  //wrong number of indices for this array
    return NULL;

  size_t i;
  for (i = 0; i < dimensionality(); ++i)
    if (index[i] >= size()[i]) //out of range
      return NULL;
  */

  //TODO remove element children after resize
  //TODO check optimization expression widget...
}

void CArrayAnnotation::print(std::ostream * ostream) const
{*ostream << *this;}

#define SPC(level) std::string(level, ' ')

void CArrayAnnotation::printRecursively(std::ostream & ostream, size_t level,
                                        CCopasiAbstractArray::index_type & index,
                                        const std::vector<std::vector<std::string> > & display) const
{
  size_t indent = 2 * (dimensionality() - 1 - level);

  if (level == 0) //only vector
    {
      ostream << SPC(indent) << "Rows: " << getDimensionDescription(level) << "\n";

      size_t imax = size()[0];

      for (index[0] = 0; index[0] < imax; ++index[0])
        ostream << SPC(indent) << display[0][index[0]] << "\t" << (*array())[index] << "\n";
    }
  else if (level == 1) //matrix
    {
      ostream << SPC(indent) << "Rows:    " << getDimensionDescription(level - 1) << "\n";
      ostream << SPC(indent) << "Columns: " << getDimensionDescription(level) << "\n";

      size_t imax = size()[0];
      size_t jmax = size()[1];
      ostream << SPC(indent);

      for (index[1] = 0; index[1] < jmax; ++index[1])
        ostream << "\t" << display[1][index[1]];

      ostream << "\n";

      for (index[0] = 0; index[0] < imax; ++index[0])
        {
          ostream << SPC(indent) << display[0][index[0]];

          for (index[1] = 0; index[1] < jmax; ++index[1])
            ostream << "\t" << (*array())[index];

          ostream << "\n";
        }
    }
  else //dimensionality > 2
    {
      size_t i, imax = size()[level];

      for (i = 0; i < imax; ++i)
        {
          ostream << SPC(indent) << getDimensionDescription(level) << ": " << display[level][i] << "\n";
          index[level] = i;
          printRecursively(ostream, level - 1, index, display);
        }
    }
}

#undef SPC

std::ostream &operator<<(std::ostream &os, const CArrayAnnotation & o)
{
  if (!o.array()) return os;

  //cache the display names
  std::vector<std::vector<std::string> > displaynames;
  size_t i;

  for (i = 0; i < o.dimensionality(); ++i)
    displaynames.push_back(o.getAnnotationsString(i));

  os << o.getObjectName() << std::endl;
  os << o.getDescription() << std::endl;

  CCopasiAbstractArray::index_type arraysize = o.array()->size();

  if (o.dimensionality() == 0)
    {
      //only one scalar value
      os << (*o.array())[arraysize] << std::endl;
    }
  else
    {
      o.printRecursively(os, o.dimensionality() - 1, arraysize, displaynames);
    }

  return os;
}

bool CArrayAnnotation::isEmpty()
{
  // either the dimension itself ...
  size_t dim = dimensionality();

  if (dim == 0) return false;

  // ... or the size of each dimension should be greater than zero.
  size_t idx = 0;

  for (idx = 0; idx < dim; idx++)
    {
      if (!size()[idx])
        return true;
    }

  return false;
}

std::string CArrayAnnotation::getObjectDisplayName(bool regular, bool richtext) const
{
  std::string part;

  if (getObjectParent() && getObjectParent()->getObjectType() != "Model")
    part = getObjectParent()->getObjectDisplayName(regular, richtext) + ".";

  return part + getObjectName() + "[[]]";
}

// void CArrayAnnotation::printDebugLoop(std::ostream & out, CCopasiAbstractArray::index_type & index, size_t level) const
//   {
//     size_t i, imax = mArray->size()[level];
//     for (i = 0; i < imax; ++i)
//       {
//         index[level] = i;
//
//         if (level == dimensionality() - 1)
//           {
//             out << (*mArray)[index] << "  ";
//}
//         else
//           {
//             printDebugLoop(out, index, level + 1);
//             out << std::endl;
//}
//}
//}
//
// void CArrayAnnotation::printDebug(std::ostream & out) const
//   {
//     out << mDescription << std::endl;
//     out << "  Dimensionality: " << dimensionality() << std::endl;
//
//     size_t i, j;
//     for (i = 0; i < dimensionality(); ++i)
//       {
//         out << "   " << i << ": " << mDimensionDescriptions[i] << std::endl;
//
//         //std::vector<std::string> names = const_cast<CArrayAnnotation*>(this)->getAnnotationsDisplay(i);
//
//         for (j = 0; j < mAnnotations[i].size(); ++j)
//           out << "     " << mAnnotations[i][j] /*<< " :" << names[j]*/ << std::endl;
//
//         out << std::endl;
//}
//
//     CCopasiAbstractArray::index_type index; index.resize(dimensionality());
//     printDebugLoop(out, index, 0);
//}