CQExperimentData Class Reference

#include <CQExperimentData.h>

Inheritance diagram for CQExperimentData:

Collaboration diagram for CQExperimentData:

Public Slots
virtual void	loadTable (CExperiment *pExperiment, const bool &guess)

Signals
void	experimentChanged ()

Public Member Functions
	CQExperimentData (QWidget *parent=0, const char *name=0, bool modal=false, Qt::WindowFlags fl=0)
virtual bool	load (CExperimentSet *pExperimentSet, CCopasiDataModel *pDataModel)
	~CQExperimentData ()

Protected Slots
void	slotCancel ()
void	slotCheckFrom (bool checked)
void	slotCheckHeader (bool checked)
void	slotCheckNormalizeWeightsPerExperiment (bool flag)
void	slotCheckTab (bool checked)
void	slotCheckTo (bool checked)
void	slotExperimentAdd ()
void	slotExperimentChanged (QListWidgetItem *pCurrentItem, QListWidgetItem *pPreviousItem)
void	slotExperimentDelete ()
void	slotExprimentType (bool isSteadyState)
void	slotFileAdd ()
void	slotFileChanged (QListWidgetItem *pCurrentItem, QListWidgetItem *pPreviousItem)
void	slotFileDelete ()
void	slotFirst ()
void	slotHeader ()
void	slotLast ()
void	slotModelObject (const QModelIndex &index)
void	slotModelObjectDelayed ()
void	slotOK ()
void	slotRevert ()
void	slotSeparator ()
void	slotTypeChanged (int row, int index)
void	slotUpdateTable ()

Protected Member Functions
void	enableEdit (const bool &enable)
bool	isLikePreviousExperiment (CExperiment *pExperiment)
virtual bool	loadExperiment (CExperiment *pExperiment)
bool	saveExperiment (CExperiment *pExperiment, const bool &full)
bool	saveTable (CExperiment *pExperiment)
void	syncExperiments ()

Protected Attributes
bool	mCrossValidation
std::map< std::string, std::string >	mFileMap
std::map< std::string, std::string >	mKeyMap
int	mModelObjectRow
unsigned int	mOldWeightMethod
CQComboDelegate *	mpComboDelegate
CCopasiDataModel *	mpDataModel
CExperiment *	mpExperiment
CExperimentSet *	mpExperimentSet
CExperimentSet *	mpExperimentSetCopy
CExperimentFileInfo *	mpFileInfo
CQExperimentDataValidator *	mpValidatorFirst
CQExperimentDataValidator *	mpValidatorHeader
CQExperimentDataValidator *	mpValidatorLast
CQExperimentDataValidator *	mpValidatorName
bool	mShowError
int	mShown
QStringList	mTypeItems
QStringList	mTypeWithoutTimeItems

Private Slots
void	slotWeightMethod (int weightMethod)

Private Member Functions
void	destroy ()
void	init ()
void	selectModelObject (const int &row)
void	setTypeItems (const int &timeRow)
void	updateScales ()

Friends
class	CQExperimentDataValidator

Detailed Description

Definition at line 31 of file CQExperimentData.h.

Constructor & Destructor Documentation

CQExperimentData::CQExperimentData	(	QWidget *	parent = 0,
		const char *	name = 0,
		bool	modal = false,
		Qt::WindowFlags	fl = 0
	)

Definition at line 66 of file CQExperimentData.cpp.

References init().

                                                                                                 :
  QDialog(parent, fl),
  mOldWeightMethod(),
  mpValidatorHeader(NULL),
  mpValidatorLast(NULL),
  mpExperiment(NULL),
  mpFileInfo(NULL),
  mpExperimentSet(NULL),
  mpExperimentSetCopy(NULL),
  mKeyMap(),
  mFileMap(),
  mpValidatorFirst(),
  mShown(-1),
  mpValidatorName(NULL),
  mCrossValidation(false),
  mShowError(true),
  mpDataModel(NULL),
  mpComboDelegate(NULL),
  mTypeItems(),
  mTypeWithoutTimeItems(),
  mModelObjectRow(-1)
{
  setObjectName(QString::fromUtf8(name));
  setModal(modal);
  setupUi(this);

  init();
}

CQExperimentData::~CQExperimentData

(

)

Definition at line 98 of file CQExperimentData.cpp.

References destroy().

{
  destroy();
  // no need to delete child widgets, Qt does it all for us
}

Member Function Documentation

void CQExperimentData::destroy ( )

private

Definition at line 824 of file CQExperimentData.cpp.

References mpExperimentSetCopy, mpFileInfo, and pdelete.

Referenced by ~CQExperimentData().

{
  pdelete(mpExperimentSetCopy);
  pdelete(mpFileInfo);
}

void CQExperimentData::enableEdit ( const bool &  enable )

protected

Definition at line 1580 of file CQExperimentData.cpp.

Referenced by slotCheckFrom(), slotExperimentChanged(), and slotExperimentDelete().

{
  if (enable)
    {
      mpBtnSteadystate->setEnabled(true);
      mpBtnTimeCourse->setEnabled(true);

      if (mpCheckHeader->isChecked()) mpEditHeader->setEnabled(true);

      mpCheckHeader->setEnabled(true);

      if (!mpCheckTab->isChecked()) mpEditSeparator->setEnabled(true);

      mpCheckTab->setEnabled(true);
      mpTable->setEnabled(true);
      mpBoxWeightMethod->setEnabled(true);

      mpCheckNormalizeWeightsPerExperiment->setEnabled(true);

      // We need to enable all items in COL_TYPE and some in COL_BTN
      // Disable is inheritted but enable not.
      /*
      if (mpExperiment)
        {
          size_t i, imax = mpTable->rowCount();

          for (i = 0; i < imax; i++)
            {
              CExperiment::Type Type = static_cast< CExperiment::Type >(mpTable->item((int) i, COL_TYPE_HIDDEN)->data(Qt::DisplayRole).toInt());

              QTableWidgetItem * pItem = mpTable->item((int) i, COL_BTN);

              if (Type == CExperiment::ignore || Type == CExperiment::time)
                {
                  pItem->setFlags(pItem->flags() & ~Qt::ItemIsEditable & ~Qt::ItemIsEnabled);
                  mpTable->closePersistentEditor(pItem);
                }
              else
                {
                  pItem->setFlags(pItem->flags() | Qt::ItemIsEditable | Qt::ItemIsEnabled);
                  mpTable->openPersistentEditor(pItem);
                }
            }
        }
        */
    }
  else
    {
      mpBtnSteadystate->setEnabled(false);
      mpBtnTimeCourse->setEnabled(false);
      mpEditHeader->setEnabled(false);
      mpCheckHeader->setEnabled(false);
      mpEditSeparator->setEnabled(false);
      mpCheckTab->setEnabled(false);
      mpTable->setEnabled(false);
      mpBoxWeightMethod->setEnabled(false);
      mpCheckNormalizeWeightsPerExperiment->setEnabled(false);
    }
}

void CQExperimentData::experimentChanged ( )

signal

Referenced by slotOK().

void CQExperimentData::init ( )

private

Definition at line 768 of file CQExperimentData.cpp.

References COL_BTN, COL_OBJECT_HIDDEN, COL_TYPE, COL_TYPE_HIDDEN, CQIconResource::copasi, CQExperimentDataValidator, CQIconResource::editAdd, CQIconResource::editDelete, CQExperimentDataValidator::FirstRow, FROM_UTF8, CQExperimentDataValidator::HeaderRow, CQIconResource::icon(), CQExperimentDataValidator::LastRow, mCrossValidation, mpComboDelegate, mpDataModel, mpExperiment, mpExperimentSetCopy, mpFileInfo, mpValidatorFirst, mpValidatorHeader, mpValidatorLast, mpValidatorName, mShowError, mTypeItems, mTypeWithoutTimeItems, CQExperimentDataValidator::Name, slotModelObject(), slotTypeChanged(), CQPushButtonDelegate::ToolButton, CExperiment::TypeName, and CExperiment::WeightMethodName.

Referenced by CQExperimentData().

{
  mpBtnFileAdd->setIcon(CQIconResource::icon(CQIconResource::editAdd));
  mpBtnFileDelete->setIcon(CQIconResource::icon(CQIconResource::editDelete));
  mpBtnExperimentAdd->setIcon(CQIconResource::icon(CQIconResource::editAdd));
  mpBtnExperimentDelete->setIcon(CQIconResource::icon(CQIconResource::editDelete));

  mpTable->hideColumn(COL_TYPE_HIDDEN);
  mpTable->hideColumn(COL_OBJECT_HIDDEN);

  mpComboDelegate = new CQComboDelegate(NULL, this);
  mpTable->setItemDelegateForColumn(COL_TYPE, mpComboDelegate);
  connect(mpComboDelegate, SIGNAL(currentIndexChanged(int, int)), this, SLOT(slotTypeChanged(int, int)));

  CQPushButtonDelegate * pButtonDelegate = new CQPushButtonDelegate(CQIconResource::icon(CQIconResource::copasi), QString(),
      CQPushButtonDelegate::ToolButton, this);
  mpTable->setItemDelegateForColumn(COL_BTN, pButtonDelegate);
  connect(pButtonDelegate, SIGNAL(clicked(const QModelIndex &)), this, SLOT(slotModelObject(const QModelIndex &)));

  const std::string * pWeightMethod = CExperiment::WeightMethodName;

  while (*pWeightMethod != "")
    mpBoxWeightMethod->insertItem(mpBoxWeightMethod->count(), FROM_UTF8(*pWeightMethod++));

  mpExperimentSetCopy = NULL;
  mpFileInfo = NULL;
  mpExperiment = NULL;

  mpValidatorName = new CQExperimentDataValidator(mpEditName, 0, this, CQExperimentDataValidator::Name);
  mpEditName->setValidator(mpValidatorName);
  mpValidatorFirst = new CQExperimentDataValidator(mpEditFirst, 0, this, CQExperimentDataValidator::FirstRow);
  mpEditFirst->setValidator(mpValidatorFirst);
  mpValidatorLast = new CQExperimentDataValidator(mpEditLast, 0, this, CQExperimentDataValidator::LastRow);
  mpEditLast->setValidator(mpValidatorLast);
  mpValidatorHeader = new CQExperimentDataValidator(mpEditHeader, 0, this, CQExperimentDataValidator::HeaderRow);
  mpEditHeader->setValidator(mpValidatorHeader);

  mCrossValidation = false;
  mShowError = true;

  mpDataModel = NULL;

  // Set the combo box items
  const std::string * pTmp = CExperiment::TypeName;

  while (*pTmp != "")
    {
      mTypeItems.push_back(FROM_UTF8(*pTmp));

      if (*pTmp != "Time")
        mTypeWithoutTimeItems.push_back(FROM_UTF8(*pTmp));

      pTmp++;
    }
}

bool CQExperimentData::isLikePreviousExperiment ( CExperiment *  pExperiment )

protected

Definition at line 1528 of file CQExperimentData.cpp.

References C_INVALID_INDEX, CExperimentSet::getExperiment(), CExperiment::getExperimentType(), CExperiment::getHeaderRow(), CExperiment::getNormalizeWeightsPerExperiment(), CExperiment::getObjectMap(), CExperiment::getSeparator(), CExperiment::getWeightMethod(), CExperimentSet::keyToIndex(), mOldWeightMethod, mpExperiment, and mpExperimentSetCopy.

Referenced by loadExperiment(), saveExperiment(), slotCheckNormalizeWeightsPerExperiment(), slotExperimentDelete(), and slotWeightMethod().

{
  if (!pExperiment) return false;

  size_t Previous =
    mpExperimentSetCopy->keyToIndex(pExperiment->CCopasiParameter::getKey()) - 1;

  if (Previous == C_INVALID_INDEX) return false;

  CExperiment * pPrevious = mpExperimentSetCopy->getExperiment(Previous);

  if (pExperiment->getSeparator() != pPrevious->getSeparator()) return false;

  if (pExperiment->getHeaderRow() != pPrevious->getHeaderRow()) return false;

  if (pExperiment->getExperimentType() != pPrevious->getExperimentType()) return false;

  if (mpExperiment != pExperiment)
    {
      if (pExperiment->getWeightMethod() != (CExperiment::WeightMethod) mOldWeightMethod) return false;

      if (pExperiment->getNormalizeWeightsPerExperiment() != pPrevious->getNormalizeWeightsPerExperiment()) return false;
    }
  else
    {
      if ((CExperiment::WeightMethod) mOldWeightMethod != pPrevious->getWeightMethod()) return false;
    }

  if (!(pExperiment->getObjectMap() == pPrevious->getObjectMap())) return false;

  return true;
}

bool CQExperimentData::load ( CExperimentSet *  pExperimentSet, CCopasiDataModel *  pDataModel  )

virtual

Definition at line 684 of file CQExperimentData.cpp.

References CCopasiParameterGroup::clear(), CDirEntry::fileName(), FROM_UTF8, CExperimentSet::getExperiment(), CExperimentSet::getExperimentCount(), CExperimentSet::getFileNames(), mCrossValidation, mFileMap, mKeyMap, mpDataModel, mpExperiment, mpExperimentSet, mpExperimentSetCopy, mpFileInfo, mShown, pdelete, slotFileChanged(), and StringPrint().

Referenced by CQFittingWidget::slotCrossValidationData(), CQFittingWidget::slotExperimentData(), and slotRevert().

{
  mpDataModel = pDataModel;

  mCrossValidation = (dynamic_cast< CCrossValidationSet * >(pExperimentSet) != NULL);

  if (mCrossValidation)
    {
      setWindowTitle("Validation Data");
      mpLblWeight->show();
      mpEditWeight->show();
      mpLblThreshold->show();
      mpEditThreshold->show();
      mpLineCrossValidation->show();

      mpEditWeight->setText(QString::number(static_cast< CCrossValidationSet * >(pExperimentSet)->getWeight()));
      mpEditThreshold->setText(QString::number(static_cast< CCrossValidationSet * >(pExperimentSet)->getThreshold()));
    }
  else
    {
      mpLblWeight->hide();
      mpEditWeight->hide();
      mpLblThreshold->hide();
      mpEditThreshold->hide();
      mpLineCrossValidation->hide();
    }

  if (!pExperimentSet) return false;

  mpExperiment = NULL;
  mShown =  -1;

  mpExperimentSet = pExperimentSet;

  pdelete(mpExperimentSetCopy);

  mpExperimentSetCopy = new CExperimentSet(*pExperimentSet);

  if (mCrossValidation)
    mpExperimentSetCopy = elevate< CCrossValidationSet, CExperimentSet >(mpExperimentSetCopy);

  pdelete(mpFileInfo);
  mpFileInfo = new CExperimentFileInfo(*mpExperimentSetCopy);

  // Build the key map so that we are able to update the correct experiments
  // on OK.
  mKeyMap.clear();
  size_t i, imax = mpExperimentSet->getExperimentCount();

  for (i = 0; i < imax; i++)
    mKeyMap[mpExperimentSet->getExperiment(i)->CCopasiParameter::getKey()] =
      mpExperimentSetCopy->getExperiment(i)->CCopasiParameter::getKey();

  // fill file list box
  mpBoxFile->clear();

  std::vector< std::string > FileNames = mpExperimentSetCopy->getFileNames();
  std::vector< std::string >::const_iterator it = FileNames.begin();
  std::vector< std::string >::const_iterator end = FileNames.end();

  std::string FileName;
  i = 0;

  mFileMap.clear();

  for (; it != end; ++it)
    {
      FileName = CDirEntry::fileName(*it);

      while (mFileMap.find(FileName) != mFileMap.end())
        FileName = StringPrint("%s_%d", CDirEntry::fileName(*it).c_str(), i++);

      mFileMap[FileName] = *it;
      mpBoxFile->addItem(FROM_UTF8(FileName));
    }

  if (mpBoxFile->count())
    mpBoxFile->setCurrentRow(0); // This triggers the rest of the update :)
  else
    slotFileChanged(NULL, NULL);

  return true;
}

bool CQExperimentData::loadExperiment ( CExperiment *  pExperiment )

protectedvirtual

Definition at line 848 of file CQExperimentData.cpp.

References COL_SCALE, FROM_UTF8, CExperimentSet::getExperiment(), CExperiment::getExperimentType(), CExperiment::getFirstRow(), CExperiment::getHeaderRow(), CExperiment::getLastRow(), CExperiment::getNormalizeWeightsPerExperiment(), CCopasiObject::getObjectName(), CExperiment::getSeparator(), CExperiment::getWeightMethod(), InvalidIndex, isLikePreviousExperiment(), CExperimentSet::keyToIndex(), loadTable(), mOldWeightMethod, mpExperimentSetCopy, mpValidatorFirst, mpValidatorHeader, mpValidatorLast, mpValidatorName, CQValidator< Type >::saved(), CExperiment::SD, CCopasiTask::timeCourse, and CExperiment::VALUE_SCALING.

Referenced by slotCheckFrom(), and slotExperimentChanged().

{

  // Temporarily disconnect signals
  mpCheckTo->blockSignals(true);
  mpCheckFrom->blockSignals(true);
  mpBtnSteadystate->blockSignals(true);
  mpEditSeparator->blockSignals(true);
  mpCheckTab->blockSignals(true);
  mpCheckNormalizeWeightsPerExperiment->blockSignals(true);

  if (!pExperiment)
    {
      mpEditName->setText("");
      mpEditSeparator->setText("");
      mpCheckTab->setChecked(true);
      mpEditFirst->setText("");
      mpEditLast->setText("");
      mpEditHeader->setText("");
      mpCheckHeader->setChecked(false);
      mpBtnTimeCourse->setChecked(true);
      mpCheckNormalizeWeightsPerExperiment->setChecked(true);
      mpCheckFrom->setChecked(false);
      mpCheckTo->setChecked(false);
      mpBoxWeightMethod->setCurrentIndex(CExperiment::SD);
    }
  else
    {
      mpEditName->setText(FROM_UTF8(pExperiment->getObjectName()));

      if (pExperiment->getSeparator() == "\t")
        {
          mpEditSeparator->setText("");
          mpCheckTab->setChecked(true);
        }
      else
        {
          mpEditSeparator->setText(FROM_UTF8(pExperiment->getSeparator()));
          mpCheckTab->setChecked(false);
        }

      QString Row = (pExperiment->getFirstRow() == InvalidIndex) ?
                    "" : QString::number(pExperiment->getFirstRow());
      mpEditFirst->setText(Row);
      Row = (pExperiment->getLastRow() == InvalidIndex) ?
            "" : QString::number(pExperiment->getLastRow());
      mpEditLast->setText(Row);

      if (pExperiment->getHeaderRow() == InvalidIndex)
        {
          mpEditHeader->setText("");
          mpCheckHeader->setChecked(false);
        }
      else
        {
          mpEditHeader->setText(QString::number(pExperiment->getHeaderRow()));
          mpCheckHeader->setChecked(true);
        }

      if (pExperiment->getExperimentType() == CCopasiTask::timeCourse)
        mpBtnTimeCourse->setChecked(true);
      else
        mpBtnSteadystate->setChecked(true);

      mOldWeightMethod = pExperiment->getWeightMethod();
      mpBoxWeightMethod->setCurrentIndex(mOldWeightMethod);

      switch ((CExperiment::WeightMethod) mOldWeightMethod)
        {
          case CExperiment::VALUE_SCALING:
            mpTable->horizontalHeaderItem(COL_SCALE)->setText("Epsilon");
            break;

          default:
            mpTable->horizontalHeaderItem(COL_SCALE)->setText("Weight");
            break;
        }

      mpCheckNormalizeWeightsPerExperiment->setChecked(pExperiment->getNormalizeWeightsPerExperiment());

      size_t Next =
        mpExperimentSetCopy->keyToIndex(pExperiment->CCopasiParameter::getKey()) + 1;

      mpCheckFrom->setChecked(isLikePreviousExperiment(pExperiment));

      if (Next < mpExperimentSetCopy->getExperimentCount())
        mpCheckTo->setChecked(isLikePreviousExperiment(mpExperimentSetCopy->getExperiment(Next)));
      else
        mpCheckTo->setChecked(false);
    }

  mpValidatorName->saved();
  mpValidatorFirst->saved();
  mpValidatorLast->saved();
  mpValidatorHeader->saved();

  // Reconnect signals
  mpCheckTo->blockSignals(false);
  mpCheckFrom->blockSignals(false);
  mpBtnSteadystate->blockSignals(false);
  mpEditSeparator->blockSignals(false);
  mpCheckTab->blockSignals(false);
  mpCheckNormalizeWeightsPerExperiment->blockSignals(false);

  loadTable(pExperiment, false);

  return true;
}

void CQExperimentData::loadTable ( CExperiment *  pExperiment, const bool &  guess  )

virtualslot

Definition at line 1124 of file CQExperimentData.cpp.

References C_FLOAT64, C_INVALID_INDEX, COL_BTN, COL_NAME, COL_OBJECT, COL_OBJECT_HIDDEN, COL_SCALE, COL_TYPE, COL_TYPE_HIDDEN, CExperiment::dependent, FROM_UTF8, CExperiment::getColumnNames(), CCopasiRootContainer::getDatamodelList(), CCopasiDataModel::getDataObject(), CExperimentObjectMap::getDefaultScale(), CExperimentObjectMap::getObjectCN(), CCopasiObject::getObjectDisplayName(), CExperiment::getObjectMap(), CExperimentObjectMap::getRole(), CExperimentObjectMap::getScale(), CExperiment::ignore, CExperiment::readColumnNames(), CExperimentObjectMap::setRole(), setTypeItems(), CExperiment::time, and CExperiment::TypeName.

Referenced by loadExperiment(), slotCheckNormalizeWeightsPerExperiment(), slotExprimentType(), slotSeparator(), slotUpdateTable(), and slotWeightMethod().

{
  if (!pExperiment)
    {
      mpTable->clearContents();
      mpTable->setRowCount(0);

      return;
    }

  size_t TimeRow = C_INVALID_INDEX;

  pExperiment->readColumnNames();
  const std::vector<std::string> & ColumnNames = pExperiment->getColumnNames();

  size_t OldRowCount = mpTable->rowCount();
  size_t i, imax = ColumnNames.size();
  mpTable->setRowCount((int)(imax));

  CExperimentObjectMap & ObjectMap = pExperiment->getObjectMap();
  const CCopasiObject *pObject;
  CExperiment::Type Type;
  QTableWidgetItem *pItem = NULL;
  assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
  CCopasiDataModel *pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
  assert(pDataModel != NULL);

  for (i = 0; i < imax; i++)
    {
      // Check whether we need to allocate table items.
      if (OldRowCount <= i)
        {
          // COL_NAME
          pItem = new QTableWidgetItem();
          pItem->setFlags(pItem->flags() & ~Qt::ItemIsEditable);
          mpTable->setItem((int) i, COL_NAME, pItem);

          // COL_TYPE
          pItem = new QTableWidgetItem();
          mpTable->setItem((int) i, COL_TYPE, pItem);

          // COL_TYPE_HIDDEN
          pItem = new QTableWidgetItem();
          pItem->setFlags(pItem->flags() & ~Qt::ItemIsEditable);
          mpTable->setItem((int) i, COL_TYPE_HIDDEN, pItem);

          // COL_BTN
          pItem = new QTableWidgetItem();
          mpTable->setItem(i, COL_BTN, pItem);

          // COL_OBJECT
          pItem = new QTableWidgetItem();
          pItem->setFlags(pItem->flags() & ~Qt::ItemIsEditable);
          mpTable->setItem((int) i, COL_OBJECT, pItem);

          // COL_OBJECT_HIDDEN
          pItem = new QTableWidgetItem();
          pItem->setFlags(pItem->flags() & ~Qt::ItemIsEditable);
          mpTable->setItem((int) i, COL_OBJECT_HIDDEN, pItem);

          // COL_SCALE
          pItem = new QTableWidgetItem("");
          mpTable->setItem((int) i, COL_SCALE, pItem);
        }

      // COL_NAME
      mpTable->item((int) i, COL_NAME)->setText(FROM_UTF8(ColumnNames[i]));

      // COL_TYPE
      if (guess && TimeRow == C_INVALID_INDEX &&
          mpBtnTimeCourse->isChecked() &&
          mpTable->item((int) i, COL_NAME)->text().contains("time", Qt::CaseInsensitive))
        {
          ObjectMap.setRole(i, CExperiment::time);
        }

      Type = ObjectMap.getRole(i);

      if (Type == CExperiment::time) TimeRow = i;

      mpTable->item((int) i, COL_TYPE)->setText(FROM_UTF8(CExperiment::TypeName[Type]));

      // COL_TYPE_HIDDEN
      mpTable->item((int) i, COL_TYPE_HIDDEN)->setText(QString::number(Type));

      // COL_BTN
      pItem = mpTable->item(i, COL_BTN);

      // Show the Button
      if (Type == CExperiment::ignore || Type == CExperiment::time)
        {
          pItem->setFlags(pItem->flags() & ~Qt::ItemIsEditable & ~Qt::ItemIsEnabled);
          mpTable->closePersistentEditor(pItem);
        }
      else
        {
          pItem->setFlags(pItem->flags() | Qt::ItemIsEditable | Qt::ItemIsEnabled);
          mpTable->openPersistentEditor(pItem);
        }

      // COL_OBJECT and COL_OBJECT_HIDDEN
      QTableWidgetItem * pItem;

      if (ObjectMap.getObjectCN(i) != "")
        {
          pObject = pDataModel->getDataObject(ObjectMap.getObjectCN(i));

          if (pObject)
            mpTable->item((int) i, COL_OBJECT)->setText(FROM_UTF8(pObject->getObjectDisplayName()));
          else
            mpTable->item((int) i, COL_OBJECT)->setText("not found");

          mpTable->item((int) i, COL_OBJECT_HIDDEN)->setText(FROM_UTF8(ObjectMap.getObjectCN(i)));
        }
      else
        {
          mpTable->item((int) i, COL_OBJECT)->setText("");
          mpTable->item((int) i, COL_OBJECT_HIDDEN)->setText("");
        }

      // COL_SCALE
      pItem = mpTable->item((int) i, COL_SCALE);

      if (Type != CExperiment::dependent)
        {
          pItem->setText("");
          pItem->setFlags(pItem->flags() & ~Qt::ItemIsEditable);
        }
      else
        {
          C_FLOAT64 DefaultScale = ObjectMap.getDefaultScale(i);
          C_FLOAT64 Scale = ObjectMap.getScale(i);

          QString ScaleText;
          Qt::ItemFlags FlagMask = Qt::NoItemFlags;

          if ((isnan(DefaultScale) && isnan(Scale)) ||
              DefaultScale == Scale)
            ScaleText = "(" + QString::number(DefaultScale) + ")";
          else
            ScaleText = QString::number(Scale);

          pItem->setText(ScaleText);
          pItem->setFlags(pItem->flags() & ~FlagMask);
        }
    }

  setTypeItems(TimeRow);

  mpTable->resizeColumnsToContents();
  mpTable->resizeRowsToContents();
}

bool CQExperimentData::saveExperiment ( CExperiment *  pExperiment, const bool &  full  )

protected

Definition at line 957 of file CQExperimentData.cpp.

References CExperimentSet::getExperiment(), CExperimentFileInfo::getFirstUnusedSection(), CCopasiObject::getObjectName(), InvalidIndex, isLikePreviousExperiment(), CExperimentSet::keyToIndex(), mpExperimentSetCopy, mpFileInfo, mpValidatorFirst, mpValidatorHeader, mpValidatorLast, mpValidatorName, mShown, CQValidator< Type >::saved(), saveTable(), CExperiment::setExperimentType(), CExperiment::setFirstRow(), CExperiment::setHeaderRow(), CExperiment::setLastRow(), CExperiment::setNormalizeWeightsPerExperiment(), CCopasiObject::setObjectName(), CExperiment::setSeparator(), CExperiment::setWeightMethod(), CCopasiTask::steadyState, CExperimentFileInfo::sync(), CCopasiTask::timeCourse, TO_UTF8, and CQExperimentDataValidator::validate().

Referenced by slotCheckTo(), slotExperimentChanged(), and updateScales().

{
  if (!pExperiment) return false;

  bool success = true;

  size_t Next =
    mpExperimentSetCopy->keyToIndex(pExperiment->CCopasiParameter::getKey()) + 1;

  if (Next < mpExperimentSetCopy->getExperimentCount() && mpCheckTo->isChecked())
    {
      CExperiment * pNext = mpExperimentSetCopy->getExperiment(Next);

      if (isLikePreviousExperiment(pNext))
        success &= saveExperiment(pNext, false);
    }

  QString value = mpEditName->text();
  int pos = value.length();

  if (full &&
      pExperiment->getObjectName() != TO_UTF8(value) &&
      mpValidatorName->validate(value, pos) == QValidator::Acceptable)
    {
      int current = mpBoxExperiment->currentRow();
      mpBoxExperiment->blockSignals(true);
      mpBoxExperiment->item(mShown)->setText(value);
      mpBoxExperiment->setCurrentRow(current);
      mpBoxExperiment->blockSignals(false);
      pExperiment->setObjectName(TO_UTF8(value));
    }

  if (mpCheckTab->isChecked())
    pExperiment->setSeparator("\t");
  else
    pExperiment->setSeparator(TO_UTF8(mpEditSeparator->text()));

  value = mpEditFirst->text();
  pos = value.length();

  if (full &&
      mpValidatorFirst->validate(value, pos) == QValidator::Acceptable)
    pExperiment->setFirstRow(value.toULong());

  value = mpEditLast->text();
  pos = value.length();

  if (full &&
      mpValidatorLast->validate(value, pos) == QValidator::Acceptable)
    pExperiment->setLastRow(value.toULong());

  value = mpEditHeader->text();
  pos = value.length();

  if (mpCheckHeader->isChecked() &&
      mpValidatorHeader->validate(value, pos) == QValidator::Acceptable)
    pExperiment->setHeaderRow(value.toULong());
  else
    {
      pExperiment->setHeaderRow(InvalidIndex);
      mpCheckHeader->setChecked(false);
    }

  if (mpBtnTimeCourse->isChecked())
    pExperiment->setExperimentType(CCopasiTask::timeCourse);
  else
    pExperiment->setExperimentType(CCopasiTask::steadyState);

  pExperiment->setWeightMethod((CExperiment::WeightMethod) mpBoxWeightMethod->currentIndex());

  pExperiment->setNormalizeWeightsPerExperiment(mpCheckNormalizeWeightsPerExperiment->isChecked());

  mpFileInfo->sync();

  size_t First, Last;
  mpBtnExperimentAdd->setEnabled(mpFileInfo->getFirstUnusedSection(First, Last));

  mpValidatorName->saved();
  mpValidatorFirst->saved();
  mpValidatorLast->saved();
  mpValidatorHeader->saved();

  saveTable(pExperiment);

  return success;
}

bool CQExperimentData::saveTable ( CExperiment *  pExperiment )

protected

Definition at line 1436 of file CQExperimentData.cpp.

References COL_OBJECT_HIDDEN, COL_SCALE, COL_TYPE, CExperiment::dependent, CExperimentObjectMap::getObjectCN(), CExperiment::getObjectMap(), CExperimentObjectMap::getRole(), CExperimentObjectMap::getScale(), CExperiment::ignore, CExperimentObjectMap::setNumCols(), CExperimentObjectMap::setObjectCN(), CExperimentObjectMap::setRole(), CExperimentObjectMap::setScale(), CExperiment::time, TO_UTF8, toEnum(), CExperiment::TypeName, and CExperiment::updateFittedPoints().

Referenced by saveExperiment(), slotCheckNormalizeWeightsPerExperiment(), slotExprimentType(), and slotWeightMethod().

{
  CExperimentObjectMap & ObjectMap = pExperiment->getObjectMap();
  size_t i, imax = mpTable->rowCount();
  bool FoundTime = false;
  bool Changed = false;

  ObjectMap.setNumCols(imax);

  for (i = 0; i < imax; i++)
    {
      CExperiment::Type Type = toEnum(TO_UTF8(mpTable->item((int) i, COL_TYPE)->text()),
                                      CExperiment::TypeName, CExperiment::ignore);

      if (Type == CExperiment::time)
        FoundTime = true;

      if (ObjectMap.getRole(i) != Type)
        {
          ObjectMap.setRole(i, Type);
          Changed = true;
        }

      if (ObjectMap.getObjectCN(i) != TO_UTF8(mpTable->item((int) i, COL_OBJECT_HIDDEN)->text()))
        {
          ObjectMap.setObjectCN(i, TO_UTF8(mpTable->item((int) i, COL_OBJECT_HIDDEN)->text()));
          Changed = true;
        }

      QString ScaleText = mpTable->item((int) i, COL_SCALE)->text();

      // Empty fields are treated as default.
      if (ScaleText == "")
        ScaleText = QString::number(std::numeric_limits<C_FLOAT64>::quiet_NaN());

      if (Type == CExperiment::dependent &&
          ScaleText[0] != '(' &&
          QString::number(ObjectMap.getScale(i)) != ScaleText)
        {
          ObjectMap.setScale(i, ScaleText.toDouble());
          Changed = true;
        }
    }

  pExperiment->updateFittedPoints();

  return Changed;
}

void CQExperimentData::selectModelObject ( const int &  row )

private

Definition at line 1088 of file CQExperimentData.cpp.

References COL_OBJECT, COL_OBJECT_HIDDEN, COL_TYPE_HIDDEN, FROM_UTF8, CCopasiObject::getCN(), CCopasiObject::getObjectDisplayName(), CCopasiSelectionDialog::getObjectSingle(), CExperiment::independent, CQSimpleSelectionTree::InitialTime, CQSimpleSelectionTree::ObservedValues, CQSimpleSelectionTree::Parameters, updateScales(), and CQSimpleSelectionTree::Variables.

Referenced by slotModelObject(), and slotModelObjectDelayed().

{
  CQSimpleSelectionTree::ObjectClasses Classes;
  CExperiment::Type Type = static_cast< CExperiment::Type >(mpTable->item(row, COL_TYPE_HIDDEN)->data(Qt::DisplayRole).toInt());

  if (Type == CExperiment::independent)
    Classes =
      CQSimpleSelectionTree::InitialTime |
      CQSimpleSelectionTree::Parameters;
  else
    Classes =
      CQSimpleSelectionTree::Variables |
      CQSimpleSelectionTree::ObservedValues;

  const CCopasiObject * pObject =
    CCopasiSelectionDialog::getObjectSingle(this, Classes);

  if (pObject)
    {
      mpTable->item(row, COL_OBJECT)->setText(FROM_UTF8(pObject->getObjectDisplayName()));
      mpTable->item(row, COL_OBJECT_HIDDEN)->setText(FROM_UTF8(pObject->getCN()));
    }

  updateScales();
}

void CQExperimentData::setTypeItems ( const int &  timeRow )

private

Definition at line 830 of file CQExperimentData.cpp.

References mpComboDelegate, mTypeItems, mTypeWithoutTimeItems, and CQComboDelegate::setItems().

Referenced by loadTable(), and slotTypeChanged().

{
  int i, imax = mpTable->rowCount();

  for (i = 0; i < imax; i++)
    {
      if ((timeRow != -1 && timeRow != i) ||
          mpBtnSteadystate->isChecked())
        {
          mpComboDelegate->setItems(i, &mTypeWithoutTimeItems);
        }
      else
        {
          mpComboDelegate->setItems(i, &mTypeItems);
        }
    }
}

void CQExperimentData::slotCancel ( )

protectedslot

Definition at line 630 of file CQExperimentData.cpp.

{
  reject();
}

void CQExperimentData::slotCheckFrom ( bool  checked )

protectedslot

Definition at line 1485 of file CQExperimentData.cpp.

References C_INT32, C_INVALID_INDEX, enableEdit(), FROM_UTF8, CExperimentFileInfo::getExperiment(), CExperiment::getFirstRow(), CExperiment::getLastRow(), CCopasiObject::getObjectName(), InvalidIndex, loadExperiment(), mOldWeightMethod, mpExperiment, mpFileInfo, mpValidatorFirst, mpValidatorLast, mpValidatorName, CQValidator< Type >::saved(), and TO_UTF8.

Referenced by slotExperimentDelete().

{
  mpCheckFrom->setFocus();

  size_t Current = this->mpBoxExperiment->currentRow();

  if (checked && Current && Current != C_INVALID_INDEX)
    {
      // Load the information from the previous experiment
      CExperiment * pPrevious =
        mpFileInfo->getExperiment(TO_UTF8(mpBoxExperiment->item((int)(Current - 1))->text()));

      unsigned C_INT32 OldWeightMethod = mOldWeightMethod;
      loadExperiment(pPrevious);
      mOldWeightMethod = OldWeightMethod;

      // Load the experiment individual information.
      mpEditName->setText(FROM_UTF8(mpExperiment->getObjectName()));
      QString Row = (mpExperiment->getFirstRow() == InvalidIndex) ?
                    "" : QString::number(mpExperiment->getFirstRow());
      mpEditFirst->setText(Row);
      Row = (mpExperiment->getLastRow() == InvalidIndex) ?
            "" : QString::number(mpExperiment->getLastRow());
      mpEditLast->setText(Row);

      mpValidatorName->saved();
      mpValidatorFirst->saved();
      mpValidatorLast->saved();
    }
  else
    {
      loadExperiment(mpExperiment);
    }

  // loadExperiment determines the status of mpCheckFrom and may have overwritten
  // the desired setting. We correct that here.
  disconnect(mpCheckFrom, SIGNAL(toggled(bool)), this, SLOT(slotCheckFrom(bool)));
  mpCheckFrom->setChecked(checked);
  connect(mpCheckFrom, SIGNAL(toggled(bool)), this, SLOT(slotCheckFrom(bool)));

  enableEdit(!checked);
}

void CQExperimentData::slotCheckHeader ( bool  checked )

protectedslot

Definition at line 375 of file CQExperimentData.cpp.

{
  mpEditHeader->setEnabled(checked);

  if (!checked)
    {
      this->mpEditHeader->setText("");
    }
}

void CQExperimentData::slotCheckNormalizeWeightsPerExperiment ( bool  flag )

protectedslot

Definition at line 1640 of file CQExperimentData.cpp.

References CExperiment::calculateWeights(), CExperiment::compile(), CLocaleString::fromUtf8(), CExperimentSet::getExperiment(), CExperiment::getFileName(), isLikePreviousExperiment(), CExperimentSet::keyToIndex(), loadTable(), mpExperiment, mpExperimentSetCopy, CExperiment::read(), saveTable(), and CExperiment::setNormalizeWeightsPerExperiment().

{
  if (!mpExperiment) return;

  size_t Current =
    mpExperimentSetCopy->keyToIndex(mpExperiment->CCopasiParameter::getKey());
  size_t Next = Current + 1;

  // Find all experiments which are like this.
  while (Next < mpExperimentSetCopy->getExperimentCount() && mpCheckTo->isChecked())
    {
      CExperiment * pNext = mpExperimentSetCopy->getExperiment(Next);

      if (!isLikePreviousExperiment(pNext)) break;

      Next++;
    }

  // Update each of them.
  while (true)
    {
      Next--;

      CExperiment * pNext = mpExperimentSetCopy->getExperiment(Next);

      bool Changed = saveTable(pNext);

      if (Changed)
        {
          std::ifstream File;
          File.open(CLocaleString::fromUtf8(pNext->getFileName()).c_str());

          size_t CurrentLine = 1;
          pNext->read(File, CurrentLine);
          pNext->compile();
        }

      pNext->setNormalizeWeightsPerExperiment(flag);
      pNext->calculateWeights();

      if (Next == Current) break;
    }

  loadTable(mpExperiment, false);
}

void CQExperimentData::slotCheckTab ( bool  checked )

protectedslot

Definition at line 359 of file CQExperimentData.cpp.

References slotSeparator().

{
  mpEditSeparator->setEnabled(!checked);

  if (checked)
    mpCheckTab->setFocus();
  else
    mpEditSeparator->setFocus();

  if (mpEditSeparator->isEnabled() &&
      mpEditSeparator->text().isEmpty())
    mpEditSeparator->setText(",");
  else
    slotSeparator();
}

void CQExperimentData::slotCheckTo ( bool  checked )

protectedslot

Definition at line 1561 of file CQExperimentData.cpp.

References C_INT32, CExperimentSet::getExperiment(), CExperiment::getWeightMethod(), CExperimentSet::keyToIndex(), mOldWeightMethod, mpExperiment, mpExperimentSetCopy, and saveExperiment().

Referenced by slotExperimentDelete().

{
  mpCheckTo->setFocus();

  if (!checked || !mpExperiment) return;

  size_t Next =
    mpExperimentSetCopy->keyToIndex(mpExperiment->CCopasiParameter::getKey()) + 1;

  if (Next < mpExperimentSetCopy->getExperimentCount())
    {
      CExperiment * pNext = mpExperimentSetCopy->getExperiment(Next);
      unsigned C_INT32 OldWeightMethod = mOldWeightMethod;
      mOldWeightMethod = pNext->getWeightMethod();
      saveExperiment(mpExperimentSetCopy->getExperiment(Next), false);
      mOldWeightMethod = OldWeightMethod;
    }
}

void CQExperimentData::slotExperimentAdd ( )

protectedslot

Definition at line 385 of file CQExperimentData.cpp.

References CExperimentSet::addExperiment(), C_INT32, FROM_UTF8, CCopasiRootContainer::getConfiguration(), CExperimentFileInfo::getFileName(), CExperimentFileInfo::getFirstUnusedSection(), CCopasiObject::getObjectName(), CExperiment::guessColumnNumber(), mpDataModel, mpExperimentSetCopy, mpFileInfo, mShowError, CExperiment::setFileName(), CExperiment::setFirstRow(), CExperiment::setHeaderRow(), CExperiment::setLastRow(), CExperiment::setNormalizeWeightsPerExperiment(), CExperiment::setNumColumns(), CExperimentFileInfo::sync(), and syncExperiments().

Referenced by slotFileAdd().

{
  mShowError = false;

  CExperiment Experiment(mpDataModel);
  CExperiment * pExperiment = mpExperimentSetCopy->addExperiment(Experiment);

  size_t First, Last;
  mpFileInfo->getFirstUnusedSection(First, Last);
  pExperiment->setFirstRow((unsigned C_INT32) First);
  pExperiment->setLastRow((unsigned C_INT32) Last);
  pExperiment->setHeaderRow((unsigned C_INT32) First);
  pExperiment->setFileName(mpFileInfo->getFileName());

  pExperiment->setNormalizeWeightsPerExperiment(CCopasiRootContainer::getConfiguration()->normalizePerExperiment());

  pExperiment->setNumColumns((unsigned C_INT32) pExperiment->guessColumnNumber());
  mpFileInfo->sync();

  mpBoxExperiment->addItem(FROM_UTF8(pExperiment->getObjectName()));
  mpBoxExperiment->setCurrentRow(mpBoxExperiment->count() - 1);

  syncExperiments();
  mpBtnExperimentAdd->setEnabled(mpFileInfo->getFirstUnusedSection(First, Last));

  mShowError = true;
}

void CQExperimentData::slotExperimentChanged ( QListWidgetItem *  pCurrentItem, QListWidgetItem *  pPreviousItem  )

protectedslot

Definition at line 413 of file CQExperimentData.cpp.

References CCopasiMessage::clearDeque(), CExperiment::compile(), enableEdit(), FROM_UTF8, CLocaleString::fromUtf8(), CCopasiMessage::getAllMessageText(), CExperimentFileInfo::getExperiment(), CExperiment::getFileName(), CQMessageBox::information(), loadExperiment(), mpExperiment, mpFileInfo, mShowError, mShown, CExperiment::read(), saveExperiment(), CCopasiMessage::size(), and TO_UTF8.

Referenced by slotExperimentDelete(), slotFileChanged(), and slotOK().

{
  std::string Name;

  if (pCurrentItem != NULL)
    Name = TO_UTF8(pCurrentItem->text());

  CCopasiMessage::clearDeque();

  bool success = true;

  saveExperiment(mpExperiment, true);

  if (pCurrentItem != NULL)
    {
      mpExperiment = mpFileInfo->getExperiment(Name);
      mShown = mpBoxExperiment->currentRow();

      std::ifstream File;
      File.open(CLocaleString::fromUtf8(mpExperiment->getFileName()).c_str());

      size_t CurrentLine = 1;
      success &= mpExperiment->read(File, CurrentLine);

      if (success)
        success &= mpExperiment->compile();
    }
  else
    {
      mpExperiment = NULL;
      mShown =  -1;
    }

  loadExperiment(mpExperiment);

  if (!success && CCopasiMessage::size() > 0 && mShowError)
    {
      CQMessageBox::information(this, "Specification Error", FROM_UTF8(CCopasiMessage::getAllMessageText()),
                                QMessageBox::Ok, QMessageBox::Ok);
      CCopasiMessage::clearDeque();
    }

  enableEdit(!mpCheckFrom->isChecked());
}

void CQExperimentData::slotExperimentDelete ( )

protectedslot

Definition at line 458 of file CQExperimentData.cpp.

References C_INVALID_INDEX, enableEdit(), CExperimentSet::getExperiment(), CExperimentFileInfo::getExperiment(), CExperimentFileInfo::getFirstUnusedSection(), isLikePreviousExperiment(), CExperimentSet::keyToIndex(), mpExperiment, mpExperimentSetCopy, mpFileInfo, CExperimentSet::removeExperiment(), slotCheckFrom(), slotCheckTo(), slotExperimentChanged(), syncExperiments(), and TO_UTF8.

{
  // Get info from current selection
  size_t index = mpBoxExperiment->currentRow();

  if (index == C_INVALID_INDEX) return;

  std::string key =
    mpFileInfo->getExperiment(TO_UTF8(mpBoxExperiment->item((int) index)->text()))->CCopasiParameter::getKey();

  // change selection
  if (mpBoxExperiment->count() > 1)
    {
      if (mpBoxExperiment->count() > (int)index + 1)
        mpBoxExperiment->setCurrentRow((int)(index + 1));
      else
        mpBoxExperiment->setCurrentRow((int)(index - 1));
    }
  else
    slotExperimentChanged(NULL, NULL);

  // remove experiment
  mpExperimentSetCopy->removeExperiment(mpExperimentSetCopy->keyToIndex(key));
  syncExperiments();

  size_t First, Last;
  mpBtnExperimentAdd->setEnabled(mpFileInfo->getFirstUnusedSection(First, Last));

  // We need to correct mpCheckFrom and mpCheckTo since the removal of the experiment
  // may have changed their status.
  disconnect(mpCheckTo, SIGNAL(toggled(bool)), this, SLOT(slotCheckTo(bool)));
  disconnect(mpCheckFrom, SIGNAL(toggled(bool)), this, SLOT(slotCheckFrom(bool)));

  mpCheckFrom->setChecked(isLikePreviousExperiment(mpExperiment));
  enableEdit(!mpCheckFrom->isChecked());

  if (mpExperiment)
    {
      size_t Next =
        mpExperimentSetCopy->keyToIndex(mpExperiment->CCopasiParameter::getKey()) + 1;

      if (Next < mpExperimentSetCopy->size())
        mpCheckTo->setChecked(isLikePreviousExperiment(mpExperimentSetCopy->getExperiment(Next)));
      else
        mpCheckTo->setChecked(false);
    }

  connect(mpCheckFrom, SIGNAL(toggled(bool)), this, SLOT(slotCheckFrom(bool)));
  connect(mpCheckTo, SIGNAL(toggled(bool)), this, SLOT(slotCheckTo(bool)));
}

void CQExperimentData::slotExprimentType ( bool  isSteadyState )

protectedslot

Definition at line 317 of file CQExperimentData.cpp.

References COL_TYPE_HIDDEN, CExperiment::getObjectMap(), CExperiment::ignore, loadTable(), mpExperiment, saveTable(), CExperiment::setExperimentType(), CExperimentObjectMap::setRole(), CCopasiTask::steadyState, CExperiment::time, and CCopasiTask::timeCourse.

{
  if (!mpExperiment) return;

  if (isSteadyState)
    {
      mpBtnSteadystate->setFocus();
      mpExperiment->setExperimentType(CCopasiTask::steadyState);
    }
  else
    {
      mpBtnTimeCourse->setFocus();
      mpExperiment->setExperimentType(CCopasiTask::timeCourse);
    }

  saveTable(mpExperiment);

  // Undo the changes so that copy from and to work.
  if (isSteadyState)
    {
      mpExperiment->setExperimentType(CCopasiTask::timeCourse);
    }
  else
    {
      mpExperiment->setExperimentType(CCopasiTask::steadyState);
    }

  size_t i, imax = mpTable->rowCount();

  if (isSteadyState)
    for (i = 0; i < imax; i++)
      {
        CExperiment::Type Type = static_cast< CExperiment::Type >(mpTable->item((int) i, COL_TYPE_HIDDEN)->data(Qt::DisplayRole).toInt());

        if (Type == CExperiment::time)
          mpExperiment->getObjectMap().setRole(i, CExperiment::ignore);
      };

  loadTable(mpExperiment, true);
  return;
}

void CQExperimentData::slotFileAdd ( )

protectedslot

Definition at line 509 of file CQExperimentData.cpp.

References CDirEntry::fileName(), FROM_UTF8, CExperimentFileInfo::getFirstUnusedSection(), CopasiFileDialog::getOpenFileName(), mFileMap, mpFileInfo, slotExperimentAdd(), StringPrint(), and TO_UTF8.

{
  QString File =
    CopasiFileDialog::getOpenFileName(this,
                                      "Open File Dialog",
                                      "",
                                      "Data Files (*.txt *.csv);;All Files (*)",
                                      "Open Data Files");

  if (File.isNull()) return;

  std::map<std::string, std::string>::const_iterator it = mFileMap.begin();
  std::map<std::string, std::string>::const_iterator end = mFileMap.end();
  int i;

  for (; it != end; ++it)
    if (it->second == TO_UTF8(File))
      {
        for (i = 0; i < mpBoxFile->count(); i++)
          if (it->first == TO_UTF8(mpBoxFile->item(i)->text()))
            {
              mpBoxFile->setCurrentRow(i);
              break;
            }

        return;
      }

  std::string FileName = CDirEntry::fileName(TO_UTF8(File));

  i = 0;

  while (mFileMap.find(FileName) != mFileMap.end())
    FileName = StringPrint("%s_%d", CDirEntry::fileName(TO_UTF8(File)).c_str(), i++);

  mFileMap[FileName] = TO_UTF8(File);
  mpBoxFile->addItem(FROM_UTF8(FileName));

  mpBoxFile->setCurrentRow(mpBoxFile->count() - 1);

  size_t First, Last;

  if (mpFileInfo->getFirstUnusedSection(First, Last))
    {
      do
        {
          slotExperimentAdd();
        }
      while (mpBtnExperimentAdd->isEnabled());

      mpBoxExperiment->setCurrentRow(0);
    }
}

void CQExperimentData::slotFileChanged ( QListWidgetItem *  pCurrentItem, QListWidgetItem *  pPreviousItem  )

protectedslot

Definition at line 563 of file CQExperimentData.cpp.

References FROM_UTF8, CExperimentFileInfo::getExperimentNames(), CExperimentFileInfo::getFirstUnusedSection(), mFileMap, mpFileInfo, CExperimentFileInfo::setFileName(), slotExperimentChanged(), and TO_UTF8.

Referenced by load(), and slotFileDelete().

{
  if (pCurrentItem)
    {
      slotExperimentChanged(NULL, NULL); // Assure that changes are saved.
      mpBoxExperiment->clear();

      if (mpFileInfo->setFileName(mFileMap[TO_UTF8(pCurrentItem->text())]))
        {
          // fill experiment list box

          std::vector< std::string > ExperimentNames = mpFileInfo->getExperimentNames();
          std::vector< std::string >::const_iterator it = ExperimentNames.begin();
          std::vector< std::string >::const_iterator end = ExperimentNames.end();

          for (; it != end; ++it)
            mpBoxExperiment->addItem(FROM_UTF8((*it)));
        }

      if (mpBoxExperiment->count())
        mpBoxExperiment->setCurrentRow(0);
      else
        slotExperimentChanged(NULL, NULL);
    }
  else
    {
      mpBoxExperiment->clear();
    }

  size_t First, Last;
  mpBtnExperimentAdd->setEnabled(mpFileInfo->getFirstUnusedSection(First, Last));
}

void CQExperimentData::slotFileDelete ( )

protectedslot

Definition at line 596 of file CQExperimentData.cpp.

References C_INVALID_INDEX, CExperimentSet::getExperiment(), CExperimentSet::getExperimentCount(), CExperiment::getFileName(), mFileMap, mpExperimentSetCopy, pdelete, CExperimentSet::removeExperiment(), slotFileChanged(), and TO_UTF8.

{
  // Get info from current selection
  size_t index = mpBoxFile->currentRow();

  if (index == C_INVALID_INDEX) return;

  std::string FileName = mFileMap[TO_UTF8(mpBoxFile->item((int) index)->text())];

  // change selection
  if (mpBoxFile->count() > 1)
    {
      if (mpBoxFile->count() > (int)index + 1)
        mpBoxFile->setCurrentRow((int)(index + 1));
      else
        mpBoxFile->setCurrentRow((int)(index - 1));
    }
  else
    slotFileChanged(NULL, NULL);

  // remove file
  mFileMap.erase(TO_UTF8(mpBoxFile->item((int) index)->text()));

  QListWidgetItem * pItem = mpBoxFile->takeItem((int) index);
  pdelete(pItem);

  // delete all experiments in current file.
  size_t i = mpExperimentSetCopy->getExperimentCount() - 1;

  for (; i != C_INVALID_INDEX; i--)
    if (mpExperimentSetCopy->getExperiment(i)->getFileName() == FileName)
      mpExperimentSetCopy->removeExperiment(i);
}

void CQExperimentData::slotFirst ( )

protectedslot

Definition at line 252 of file CQExperimentData.cpp.

References C_INVALID_INDEX.

{
  qWarning("CQExperimentData::slotFirst(): Not implemented yet");

  size_t Row = C_INVALID_INDEX;

  if (mpEditFirst->text() != "")
    Row = mpEditFirst->text().toULong();

  if (Row == C_INVALID_INDEX)
    {
      //  Row = find first non used row in file
    }

  // display dialog with table showing file section of First row

  // if accept
  //  set mpEditFirst
}

void CQExperimentData::slotHeader ( )

protectedslot

Definition at line 297 of file CQExperimentData.cpp.

{
  qWarning("CQExperimentData::slotHeader(): Not implemented yet");

  // if header row
  //  display table showing file section of header row inexperiment
  // if first row
  //  display table showing file section of first row inexperiment
  // else if last row
  //  display table showing file section of last row inexperiment
  // else
  //  display table showing file section of  first non used row in file

  // if accept
  //  set mpEditHeader
  //  check mpCheckHeader
  // else
  // uncheck mpCheckHeader
}

void CQExperimentData::slotLast ( )

protectedslot

Definition at line 272 of file CQExperimentData.cpp.

References C_INVALID_INDEX.

{
  size_t Row = C_INVALID_INDEX;

  if (mpEditLast->text() != "")
    Row = mpEditLast->text().toULong();

  if (Row == C_INVALID_INDEX && mpEditFirst->text() != "")
    Row = mpEditFirst->text().toULong();

  // display dialog with table showing file section of First row

  // if accept
  //  set mpEditFirst
  // if last row
  //  display table showing file section of last row inexperiment
  // else if  first
  //  display table showing file section of  first row in file
  // else
  //  display table showing file section of last non used row in file

  // if accept
  //  set mpEditLast
}

void CQExperimentData::slotModelObject ( const QModelIndex &  index )

protectedslot

Definition at line 1083 of file CQExperimentData.cpp.

References selectModelObject().

Referenced by init().

{
  selectModelObject(index.row());
}

void CQExperimentData::slotModelObjectDelayed ( )

protectedslot

Definition at line 1114 of file CQExperimentData.cpp.

References mModelObjectRow, and selectModelObject().

Referenced by slotTypeChanged().

{
  if (mModelObjectRow != -1)
    {
      selectModelObject(mModelObjectRow);
    }

  mModelObjectRow = -1;
}

void CQExperimentData::slotOK ( )

protectedslot

Definition at line 635 of file CQExperimentData.cpp.

References CExperimentSet::addExperiment(), C_INVALID_INDEX, experimentChanged(), CKeyFactory::get(), CExperimentSet::getExperiment(), CExperimentSet::getExperimentCount(), CCopasiRootContainer::getKeyFactory(), CCopasiObject::getObjectName(), CCrossValidationSet::getThreshold(), CCrossValidationSet::getWeight(), mCrossValidation, mKeyMap, mpExperimentSet, mpExperimentSetCopy, pdelete, CExperimentSet::removeExperiment(), CCopasiParameterGroup::removeParameter(), CCrossValidationSet::setThreshold(), CCrossValidationSet::setWeight(), and slotExperimentChanged().

{
  mpBtnOK->setFocus();

  // Force the save all current changes.
  slotExperimentChanged(NULL, NULL);

  CExperiment * pExperiment;

  size_t i = mpExperimentSet->getExperimentCount() - 1;

  for (; i != C_INVALID_INDEX; i--)
    {
      pExperiment =
        dynamic_cast<CExperiment *>(CCopasiRootContainer::getKeyFactory()->get(mKeyMap[mpExperimentSet->getExperiment(i)->CCopasiParameter::getKey()]));

      if (pExperiment)
        {
          *mpExperimentSet->getExperiment(i) = *pExperiment;
          mpExperimentSetCopy->removeParameter(pExperiment->getObjectName());
        }
      else
        mpExperimentSet->removeExperiment(i);
    }

  emit experimentChanged();

  for (i = 0; i < mpExperimentSetCopy->getExperimentCount(); i++)
    mpExperimentSet->addExperiment(*mpExperimentSetCopy->getExperiment(i));

  if (mCrossValidation)
    {
      CCrossValidationSet * pSet = static_cast< CCrossValidationSet * >(mpExperimentSet);

      if (QString::number(pSet->getWeight()) != mpEditWeight->text())
        {
          pSet->setWeight(mpEditWeight->text().toDouble());
        }

      if (QString::number(pSet->getThreshold()) != mpEditThreshold->text())
        {
          pSet->setThreshold(mpEditThreshold->text().toUInt());
        }
    }

  pdelete(mpExperimentSetCopy);
  accept();
}

void CQExperimentData::slotRevert ( )

protectedslot

Definition at line 247 of file CQExperimentData.cpp.

References load(), mpDataModel, and mpExperimentSet.

{
  load(mpExperimentSet, mpDataModel);
}

void CQExperimentData::slotSeparator ( )

protectedslot

Definition at line 1419 of file CQExperimentData.cpp.

References C_INT32, CExperiment::guessColumnNumber(), loadTable(), mpExperiment, CExperiment::readColumnNames(), CExperiment::setNumColumns(), CExperiment::setSeparator(), and TO_UTF8.

Referenced by slotCheckTab().

{
  if (!mpExperiment) return;

  //  saveTable(mpExperiment);

  if (mpCheckTab->isChecked())
    mpExperiment->setSeparator("\t");
  else
    mpExperiment->setSeparator(TO_UTF8(mpEditSeparator->text()));

  mpExperiment->setNumColumns((unsigned C_INT32) mpExperiment->guessColumnNumber());
  mpExperiment->readColumnNames();

  loadTable(mpExperiment, true);
}

void CQExperimentData::slotTypeChanged ( int  row, int  index  )

protectedslot

Definition at line 1277 of file CQExperimentData.cpp.

References COL_BTN, COL_OBJECT_HIDDEN, COL_TYPE, COL_TYPE_HIDDEN, CExperiment::dependent, CQSimpleSelectionTree::filter(), FROM_UTF8, CCopasiRootContainer::getDatamodelList(), CCopasiDataModel::getDataObject(), CExperiment::ignore, CExperiment::independent, CQSimpleSelectionTree::InitialTime, mModelObjectRow, CQSimpleSelectionTree::ObservedValues, CQSimpleSelectionTree::Parameters, setTypeItems(), slotModelObjectDelayed(), CExperiment::time, TO_UTF8, CExperiment::TypeName, updateScales(), and CQSimpleSelectionTree::Variables.

Referenced by init().

{
  CExperiment::Type NewType = static_cast<CExperiment::Type>(index);
  CExperiment::Type OldType = static_cast<CExperiment::Type>(mpTable->item(row, COL_TYPE_HIDDEN)->data(Qt::DisplayRole).toInt());

  if (OldType == NewType) return;

  bool BtnEnabled = true;
  //C_INT32 i, imax = mpTable->rowCount();

  mpTable->item(row, COL_TYPE)->setText(QString(FROM_UTF8(CExperiment::TypeName[NewType])));
  mpTable->item(row, COL_TYPE_HIDDEN)->setText(QString::number(NewType));

  CCopasiObjectName CN = CCopasiObjectName(TO_UTF8(mpTable->item(row, COL_OBJECT_HIDDEN)->text()));
  assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
  CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
  assert(pDataModel != NULL);

  switch (NewType)
    {
      case CExperiment::ignore:
        BtnEnabled = false;
        break;

      case CExperiment::independent:

        if (!CQSimpleSelectionTree::filter(CQSimpleSelectionTree::InitialTime |
                                           CQSimpleSelectionTree::Parameters,
                                           pDataModel->getDataObject(CN)))
          {
            mModelObjectRow = row;
            // slotModelObject(row);
            QTimer::singleShot(10, this, SLOT(slotModelObjectDelayed()));
          }

        BtnEnabled = true;
        break;

      case CExperiment::dependent:

        if (!CQSimpleSelectionTree::filter(CQSimpleSelectionTree::Variables |
                                           CQSimpleSelectionTree::ObservedValues,
                                           pDataModel->getDataObject(CN)))
          {
            mModelObjectRow = row;
            // slotModelObject(row);
            QTimer::singleShot(10, this, SLOT(slotModelObjectDelayed()));
          }

        BtnEnabled = true;
        break;

      case CExperiment::time:
        BtnEnabled = false;
        setTypeItems(row);

        break;
    }

  QTableWidgetItem * pItem = mpTable->item(row, COL_BTN);

  if (BtnEnabled)
    {
      pItem->setFlags(pItem->flags() | Qt::ItemIsEditable | Qt::ItemIsEnabled);
      mpTable->openPersistentEditor(pItem);
    }
  else
    {
      pItem->setFlags(pItem->flags() & ~Qt::ItemIsEditable & ~Qt::ItemIsEnabled);
      mpTable->closePersistentEditor(pItem);
    }

  switch (OldType)
    {
      case CExperiment::ignore:
      case CExperiment::independent:
      case CExperiment::dependent:
        break;

      case CExperiment::time:
        setTypeItems(-1);
        break;
    }

  // The default weights need to be recalculated and the table updated if the type change
  // involves dependent values.
  if (OldType == CExperiment::dependent ||
      NewType == CExperiment::dependent)
    {
      updateScales();
    }

  return;
}

void CQExperimentData::slotUpdateTable ( )

protectedslot

Definition at line 1080 of file CQExperimentData.cpp.

References loadTable(), and mpExperiment.

{loadTable(mpExperiment, true);}

void CQExperimentData::slotWeightMethod ( int  weightMethod )

privateslot

Definition at line 1686 of file CQExperimentData.cpp.

References CExperiment::calculateWeights(), COL_SCALE, CExperiment::compile(), CLocaleString::fromUtf8(), CExperimentSet::getExperiment(), CExperiment::getFileName(), CExperiment::getWeightMethod(), isLikePreviousExperiment(), CExperimentSet::keyToIndex(), loadTable(), mpExperiment, mpExperimentSetCopy, CExperiment::read(), saveTable(), CExperiment::setWeightMethod(), and CExperiment::VALUE_SCALING.

{
  if (mpExperiment == NULL) return;

  if ((CExperiment::WeightMethod) weightMethod ==
      mpExperiment->getWeightMethod()) return;

  switch ((CExperiment::WeightMethod) weightMethod)
    {
      case CExperiment::VALUE_SCALING:
        mpTable->horizontalHeaderItem(COL_SCALE)->setText("Epsilon");
        break;

      default:
        mpTable->horizontalHeaderItem(COL_SCALE)->setText("Weight");
        break;
    }

  size_t Current =
    mpExperimentSetCopy->keyToIndex(mpExperiment->CCopasiParameter::getKey());
  size_t Next = Current + 1;

  // Find all experiments which are like this.
  while (Next < mpExperimentSetCopy->getExperimentCount() && mpCheckTo->isChecked())
    {
      CExperiment * pNext = mpExperimentSetCopy->getExperiment(Next);

      if (!isLikePreviousExperiment(pNext)) break;

      Next++;
    }

  // Update each of them.
  while (true)
    {
      Next--;

      CExperiment * pNext = mpExperimentSetCopy->getExperiment(Next);

      bool Changed = saveTable(pNext);

      if (Changed)
        {
          std::ifstream File;
          File.open(CLocaleString::fromUtf8(pNext->getFileName()).c_str());

          size_t CurrentLine = 1;
          pNext->read(File, CurrentLine);
          pNext->compile();
        }

      pNext->setWeightMethod((CExperiment::WeightMethod) weightMethod);
      pNext->calculateWeights();

      if (Next == Current) break;
    }

  loadTable(mpExperiment, false);
}

void CQExperimentData::syncExperiments ( )

protected

Definition at line 1044 of file CQExperimentData.cpp.

References FROM_UTF8, CExperimentFileInfo::getExperimentNames(), mpFileInfo, mShown, CExperimentFileInfo::sync(), and TO_UTF8.

Referenced by slotExperimentAdd(), slotExperimentDelete(), and CQExperimentDataValidator::validate().

{
  std::string Current = TO_UTF8(mpBoxExperiment->currentItem()->text());
  std::string Shown;

  if (mShown != -1)
    Shown = TO_UTF8(mpBoxExperiment->item(mShown)->text());

  mpFileInfo->sync();

  mpBoxExperiment->blockSignals(true);
  mpBoxExperiment->clear();

  std::vector< std::string > ExperimentNames = mpFileInfo->getExperimentNames();
  std::vector< std::string >::const_iterator it = ExperimentNames.begin();
  std::vector< std::string >::const_iterator end = ExperimentNames.end();

  int i;

  for (i = 0; it != end; ++it, i++)
    {
      mpBoxExperiment->addItem(FROM_UTF8((*it)));

      if (*it == Current)
        {
          mpBoxExperiment->setCurrentRow(mpBoxExperiment->count() - 1);
        }

      if (*it == Shown) mShown = i;
    }

  mpBoxExperiment->blockSignals(false);

  return;
}

void CQExperimentData::updateScales ( )

private

Definition at line 1372 of file CQExperimentData.cpp.

References C_FLOAT64, C_INT32, COL_SCALE, CExperiment::compile(), CExperiment::dependent, CLocaleString::fromUtf8(), CExperimentObjectMap::getDefaultScale(), CExperiment::getFileName(), CExperiment::getObjectMap(), CExperimentObjectMap::getRole(), mpExperiment, CExperiment::read(), and saveExperiment().

Referenced by selectModelObject(), and slotTypeChanged().

{
  saveExperiment(mpExperiment, true);

  // Since the interpretation of the data has changed we need read the file again
  std::ifstream File;
  File.open(CLocaleString::fromUtf8(mpExperiment->getFileName()).c_str());

  size_t CurrentLine = 1;
  mpExperiment->read(File, CurrentLine);
  mpExperiment->compile();

  // We can not simply use loadTable as this would destroy the two signal maps
  // for the buttons and comboboxes leading to crashes in Qt.
  CExperimentObjectMap & ObjectMap = mpExperiment->getObjectMap();

  C_INT32 i, imax = mpTable->rowCount();

  for (i = 0; i < imax; i++)
    {
      QTableWidgetItem * pItem = mpTable->item(i, COL_SCALE);

      // COL_SCALE
      if (ObjectMap.getRole(i) != CExperiment::dependent)
        {
          pItem->setText("");
          pItem->setFlags(pItem->flags() & ~Qt::ItemIsEditable);
        }
      else
        {
          QString ScaleText = pItem->text();

          // Keep non default values
          if (ScaleText == "" || ScaleText[0] == '(')
            {

              C_FLOAT64 DefaultWeight = ObjectMap.getDefaultScale(i);

              ScaleText = "(" + QString::number(DefaultWeight) + ")";
              pItem->setText(ScaleText);
            }

          pItem->setFlags(pItem->flags() | Qt::ItemIsEditable);
        }
    }
}

Friends And Related Function Documentation

friend class CQExperimentDataValidator

friend

Definition at line 39 of file CQExperimentData.h.

Referenced by init().

Member Data Documentation

bool CQExperimentData::mCrossValidation

protected

Definition at line 62 of file CQExperimentData.h.

Referenced by init(), load(), and slotOK().

std::map<std::string, std::string> CQExperimentData::mFileMap

protected

Definition at line 58 of file CQExperimentData.h.

Referenced by load(), slotFileAdd(), slotFileChanged(), and slotFileDelete().

std::map<std::string, std::string> CQExperimentData::mKeyMap

protected

Definition at line 57 of file CQExperimentData.h.

Referenced by load(), and slotOK().

int CQExperimentData::mModelObjectRow

protected

Definition at line 68 of file CQExperimentData.h.

Referenced by slotModelObjectDelayed(), and slotTypeChanged().

unsigned int CQExperimentData::mOldWeightMethod

protected

Definition at line 50 of file CQExperimentData.h.

Referenced by isLikePreviousExperiment(), loadExperiment(), slotCheckFrom(), and slotCheckTo().

CQComboDelegate* CQExperimentData::mpComboDelegate

protected

Definition at line 65 of file CQExperimentData.h.

Referenced by init(), and setTypeItems().

CCopasiDataModel* CQExperimentData::mpDataModel

protected

Definition at line 64 of file CQExperimentData.h.

Referenced by init(), load(), slotExperimentAdd(), and slotRevert().

CExperiment* CQExperimentData::mpExperiment

protected

Definition at line 53 of file CQExperimentData.h.

Referenced by init(), isLikePreviousExperiment(), load(), slotCheckFrom(), slotCheckNormalizeWeightsPerExperiment(), slotCheckTo(), slotExperimentChanged(), slotExperimentDelete(), slotExprimentType(), slotSeparator(), slotUpdateTable(), slotWeightMethod(), updateScales(), and CQExperimentDataValidator::validate().

CExperimentSet* CQExperimentData::mpExperimentSet

protected

Definition at line 55 of file CQExperimentData.h.

Referenced by load(), slotOK(), and slotRevert().

CExperimentSet* CQExperimentData::mpExperimentSetCopy

protected

Definition at line 56 of file CQExperimentData.h.

Referenced by destroy(), init(), isLikePreviousExperiment(), load(), loadExperiment(), saveExperiment(), slotCheckNormalizeWeightsPerExperiment(), slotCheckTo(), slotExperimentAdd(), slotExperimentDelete(), slotFileDelete(), slotOK(), slotWeightMethod(), and CQExperimentDataValidator::validate().

CExperimentFileInfo* CQExperimentData::mpFileInfo

protected

Definition at line 54 of file CQExperimentData.h.

Referenced by destroy(), init(), load(), saveExperiment(), slotCheckFrom(), slotExperimentAdd(), slotExperimentChanged(), slotExperimentDelete(), slotFileAdd(), slotFileChanged(), syncExperiments(), and CQExperimentDataValidator::validate().

CQExperimentDataValidator* CQExperimentData::mpValidatorFirst

protected

Definition at line 59 of file CQExperimentData.h.

Referenced by init(), loadExperiment(), saveExperiment(), and slotCheckFrom().

CQExperimentDataValidator* CQExperimentData::mpValidatorHeader

protected

Definition at line 51 of file CQExperimentData.h.

Referenced by init(), loadExperiment(), and saveExperiment().

CQExperimentDataValidator* CQExperimentData::mpValidatorLast

protected

Definition at line 52 of file CQExperimentData.h.

Referenced by init(), loadExperiment(), saveExperiment(), slotCheckFrom(), and CQExperimentDataValidator::validate().

CQExperimentDataValidator* CQExperimentData::mpValidatorName

protected

Definition at line 61 of file CQExperimentData.h.

Referenced by init(), loadExperiment(), saveExperiment(), and slotCheckFrom().

bool CQExperimentData::mShowError

protected

Definition at line 63 of file CQExperimentData.h.

Referenced by init(), slotExperimentAdd(), and slotExperimentChanged().

int CQExperimentData::mShown

protected

Definition at line 60 of file CQExperimentData.h.

Referenced by load(), saveExperiment(), slotExperimentChanged(), syncExperiments(), and CQExperimentDataValidator::validate().

QStringList CQExperimentData::mTypeItems

protected

Definition at line 66 of file CQExperimentData.h.

Referenced by init(), and setTypeItems().

QStringList CQExperimentData::mTypeWithoutTimeItems

protected

Definition at line 67 of file CQExperimentData.h.

Referenced by init(), and setTypeItems().

---

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

• CQExperimentData.h
• CQExperimentData.cpp