EI/VirtualLeaf Changeset - 15d600891648 · Centrum Wiskunde & Informatica (CWI)

Changeset - 15d600891648

Parent rev.

Child rev.

[Not reviewed]

default

! ! !

Michael Guravage - 15 years ago 2010-06-24 15:22:58
michael.guravage@cwi.nl

In DrawCell class (VirtualLeaf.cpp) - iterate over NChem to construct info_string. Additional cleanup.

--
user: Michael Guravage <michael.guravage@cwi.nl>
branch 'default'
changed src/ChangeLog
changed src/Neighbor.cpp
changed src/Neighbor.h
changed src/OptionFileDialog.cpp
changed src/OptionFileDialog.h
changed src/UniqueMessage.cpp
changed src/UniqueMessage.h
changed src/VirtualLeaf.cpp
changed src/VirtualLeaf.pro
changed src/build_models/plugin_auxingrowth.pro
changed src/build_models/plugin_meinhardt.pro
changed src/build_models/plugin_test.pro
changed src/canvas.cpp
changed src/canvas.h
changed src/cell.cpp
changed src/cell.h
changed src/cellbase.cpp
changed src/cellbase.h
changed src/cellitem.cpp
changed src/cellitem.h
changed src/forwardeuler.cpp
changed src/forwardeuler.h
changed src/infobar.h
changed src/libplugin.pro
changed src/mainbase.cpp
changed src/mainbase.h
changed src/matrix.cpp
changed src/matrix.h
changed src/mesh.cpp
changed src/mesh.h
changed src/miscq.cpp
changed src/miscq.h
changed src/modelcatalogue.cpp
changed src/modelcatalogue.h
changed src/node.cpp
changed src/node.h
changed src/nodeitem.cpp
changed src/nodeitem.h
changed src/nodeset.cpp
changed src/nodeset.h
changed src/output.cpp
changed src/output.h
changed src/parameter.cpp
changed src/parameter.h
changed src/pardialog.cpp
changed src/parse.cpp
changed src/parse.h
changed src/pi.h
changed src/qcanvasarrow.h
changed src/random.cpp
changed src/random.h
changed src/rungekutta.cpp
changed src/rungekutta.h
changed src/simitembase.cpp
changed src/simitembase.h
changed src/simplugin.h
changed src/sqr.h
changed src/tiny.h
changed src/transporterdialog.cpp
changed src/transporterdialog.h
changed src/vector.cpp
changed src/vector.h
changed src/wall.cpp
changed src/wall.h
changed src/wallbase.cpp
changed src/wallbase.h
changed src/wallitem.cpp
changed src/wallitem.h
changed src/warning.cpp
changed src/warning.h
changed src/xmlwrite.cpp
changed src/xmlwrite.h

62 files changed:

src/ChangeLog

src/Neighbor.cpp

src/Neighbor.h

src/OptionFileDialog.cpp

src/OptionFileDialog.h

src/UniqueMessage.cpp

src/UniqueMessage.h

src/VirtualLeaf.cpp

src/VirtualLeaf.pro

src/build_models/plugin_auxingrowth.pro

src/build_models/plugin_meinhardt.pro

src/build_models/plugin_test.pro

src/canvas.cpp

src/canvas.h

src/cell.cpp

src/cell.h

src/cellbase.cpp

src/cellbase.h

src/cellitem.cpp

src/cellitem.h

src/forwardeuler.cpp

src/forwardeuler.h

src/infobar.h

src/libplugin.pro

src/mainbase.cpp

src/mainbase.h

src/matrix.cpp

src/matrix.h

src/mesh.cpp

src/mesh.h

src/miscq.cpp

src/miscq.h

src/modelcatalogue.cpp

src/modelcatalogue.h

src/node.cpp

src/node.h

src/nodeitem.cpp

src/nodeitem.h

src/nodeset.cpp

src/nodeset.h

src/output.cpp

src/output.h

src/parameter.cpp

src/parameter.h

src/pardialog.cpp

src/parse.cpp

src/parse.h

src/pi.h

src/qcanvasarrow.h

src/random.cpp

src/random.h

src/rungekutta.cpp

src/rungekutta.h

src/simitembase.cpp

src/simitembase.h

src/simplugin.h

src/sqr.h

src/tiny.h

src/transporterdialog.cpp

src/transporterdialog.h

src/vector.cpp

src/vector.h

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)

src/ChangeLog

➞

Show inline comments

 -06-24    <guravage@caterpie.sen.cwi.nl>
 	* VirtualLeaf.cpp (DrawCell): Iterate over NChem to construct info_string.
 -06-23    <guravage@caterpie.sen.cwi.nl>
 	* simitembase.cpp: Removed NULL assignments to unused variables.
 	* VirtualLeaf.cpp: Ditto.
 	* apoplastitem.cpp: Ditto.
 	* canvas.cpp: Ditto.
 	* cell.cpp: Ditto.
 	* cellbase.h: Ditto.
 	* forwardeuler.cpp: Ditto.
 	* mainbase.h: Ditto.
 	* nodeitem.cpp: Ditto.
 	* qcanvasarrow.h: Ditto.
 	* simitembase.cpp: Ditto.
 	* Makefile (clean): Add -f Makefile argument to each make invocation.
 	* VirtualLeaf-install.nsi: New gpl license text.
 	* VirtualLeaf.pro: Disabled console mode.
 	* mesh.cpp (Clear): Added parentheses to qDebug statments.
 	(TestIllegalWalls): Replaced qDebug().
 	* canvas.cpp (mouseReleaseEvent): Replaced qDebug() with cerr since qDebug complains about *node_set.
 	* wall.cpp (CorrectWall): Rplaced gDebug() with cerr in transform call and when printing *this.
 -06-22    <guravage@caterpie.sen.cwi.nl>
 	* Makefile (tutorials): Add tutorials target.
 -06-21    <guravage@caterpie.sen.cwi.nl>
 	* parameter.cpp: Added particular reassignment of datadir.
 	* canvas.cpp (gpl): Added GPL3 License text. Display detail text only if the source text file exists.
 -06-18    <guravage@caterpie.sen.cwi.nl>
 	* canvas.cpp (gpl): Added gpl slot to display GPL license.
 	* VirtualLeaf.pro: Changed default LIBXML2DIR, LIBICONVDIR and LIBZDIR to corresponding distribution lib directories.
 	* libplugin.pro: Ditto.
 	* Makefile (clean): add if stmt not to `touch` on windows.
 -06-17    <guravage@caterpie.sen.cwi.nl>
 	* VirtualLeaf.pro: Removed perl references.
 	* libplugin.pro: Ditto.
 -06-15    <guravage@caterpie.sen.cwi.nl>
 	* VirtualLeaf.pro: Removed xmlwritecode.cpp from SOURCES list.
 	* xmlwrite.cpp (XMLSave): Removed references to XMLWriteLeafSourceCode and XMLWriteReactionsCode.
 	* xmlwrite.h (XMLIO): Ditto!
 	* mesh.cpp (findNextBoundaryNode): Initialize Node *next_boundary_node = NULL;
 	* xmlwrite.cpp (XMLReadSimtime): Removed unused variable cur
 	(XMLReadWalls): viz_flux need not be declared twice; default value of 0.0.
 	(XMLReadCells): Removed unused count variable.
 	(XMLReadSimtime): Removed unused cur variable.
 	(XMLRead): Removed unused v_str variable.
 	* simitembase.cpp (userMove): Use assignment merely to obviate compilation warning.
 	(SimItemBase) Ditto.
 	* qcanvasarrow.h (QGraphicsLineItem): Use assignment merely to obviate compilation warning.
 	* output.cpp (OpenWriteFile): Removed unused par variable.
 	* nodeitem.cpp (paint): Use assignment merely to obviate compilation warning.
 	* forwardeuler.cpp (odeint): Use assignment merely to obviate compilation warning.
 	* cell.cpp (DivideOverGivenLine): Use assignment merely to obviate compilation warning.
 	* canvas.cpp (FigureEditor): Use assignments merely to obviate compilation errors.
 	(mousePressEvent): Removed unused item variable.
 	* apoplastitem.cpp
 	(ApoplastItem): Removed unused par variable.
 	(OnClick): Use NULL assignment merely to obviate compilation warning.
 	* mainbase.h (MainBase): Use assignment merely to obviate compilation warning.
 	* cellbase.h (CellsStaticDatamembers): Use assignment merely to obviate compilation warning.
 	* cell.cpp: Wrapped diagnostic output in QDEBUG blocks.
 	* VirtualLeaf.cpp ditto.
 	* canvas.cpp ditto.
 	* cell.cpp ditto.

src/Neighbor.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include "Neighbor.h"
 #include "cell.h"
 #include <string>
 static const std::string _module_id("$Id$");
 Neighbor::Neighbor(void):
-  cell(NULL), nb1(NULL), nb2(NULL){}
+  cell(0), nb1(0), nb2(0){}
 Neighbor::Neighbor(Cell *c, Node *n1, Node *n2):
   cell(c), nb1(n1), nb2(n2){}
 Neighbor::Neighbor(const Neighbor &src):
   cell(src.cell), nb1(src.nb1), nb2(src.nb2){} // copy constructor
 bool Neighbor::CellEquals(int i) const { return cell->Index() == i; }
 bool Neighbor::Cmp(Neighbor &c) const { return cell->Index() < c.cell->Index(); } // Compare cell indices not pointers.
 bool Neighbor::Eq(Neighbor &c) const { return cell->Index() == c.cell->Index(); }
 Cell* Neighbor::getCell(void) const { return cell; }
 bool neighbor_cell_eq(const Neighbor &n1, const Neighbor &n2) {
   return (n1.getCell())->Index() == (n2.getCell())->Index(); // Compare cell indices not pointers.
+}
 /* finis */

src/Neighbor.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _NEIGHBOR_H_
 #define _NEIGHBOR_H_
 #include <iostream>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 using namespace std;
 class Cell;
 class Node;
 class Neighbor {
  protected:
   // Proper accessors and mutators should obviate these friend classes!
   friend class Cell;
   friend class Mesh;
   friend class Node;
   friend class FigureEditor;
   Cell *cell;
   Node *nb1, *nb2;
  public:
   Neighbor(void);
   Neighbor(Cell*, Node*, Node*);
   Neighbor(const Neighbor&);
   bool CellEquals(int) const;
   bool Cmp(Neighbor&) const;
   bool Eq(Neighbor&) const;
   Cell* getCell(void) const;
   void XMLAdd(xmlNodePtr) const;
   ostream &print(ostream &os) const;
 };
 // Overload the << operator
 ostream &operator<<(ostream &os, const Neighbor &n);
 // Realize that we're equating like pointers with object equivalence!
 bool neighbor_cell_eq(const Neighbor &n1, const Neighbor &n2);
 #endif
 /* finis */

src/OptionFileDialog.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include "OptionFileDialog.h"
 #include <QCheckBox>
 #include <iostream>
 using namespace  std;
 static const std::string _module_id("$Id$");
 OptionFileDialog::OptionFileDialog(QWidget *parent, const char *name, bool modal) : Q3FileDialog(parent, name, modal)
+{
   //cerr << "This is an OptionFileDialog\n";
   geometrycheck = new QCheckBox("geometry",this);
   geometrycheck -> setCheckState(Qt::Checked);
   parcheck = new QCheckBox("parameters", this);
   parcheck -> setCheckState(Qt::Checked);
   addToolButton(geometrycheck);
   addToolButton(parcheck);
 };
 OptionFileDialog::OptionFileDialog ( const QString & dirName, const QString & filter ,
 				     QWidget * parent, const char * name , bool modal  ) :
   Q3FileDialog(dirName, filter, parent, name, modal) {
   cerr << "This is an OptionFileDialog\n";
 };
 /* finis */

src/OptionFileDialog.h

➞

Show inline comments

 /*
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _OPTIONFILEDIALOG_H_
 #define _OPTIONFILEDIALOG_H_
 #include <Q3FileDialog>
 #include <QCheckBox>
 class OptionFileDialog : public Q3FileDialog {
   Q_OBJECT
  public:
   OptionFileDialog(QWidget *parent = 0, const char *name = 0, bool modal = false);
   OptionFileDialog ( const QString & dirName, const QString & filter = QString(),
 		     QWidget * parent = 0, const char * name = 0, bool modal = false );
   bool readGeometryP(void) const { return geometrycheck->checkState()==Qt::Checked; }
   bool readParametersP(void) const { return parcheck->checkState()==Qt::Checked; }
  private:
   QCheckBox *geometrycheck;
   QCheckBox *parcheck;
 };
 #endif
 /* finis */

src/UniqueMessage.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <QMessageBox>
 #include <QCheckBox>
 #include <QPushButton>
 #include <QBoxLayout>
 #include "UniqueMessage.h"
 #include <iostream>
 static const std::string _module_id("$Id$");
 using namespace std;
 UniqueMessageBox::UniqueMessageBox ( /* Icon icon,*/
 				    const QString & title,
 				    const QString & text,
 				    QWidget * parent ,
 				    Qt::WindowFlags f ) :
   QDialog(parent, f) {
   label = new QLabel(text);
   boxtext = text;
   show_again = new QCheckBox(tr("Do not show this message again"));
   okButton = new QPushButton(tr("Ok"));
   if (issued_messages.contains(boxtext) ) {
     cerr << "Saw message before\n";
     display = false;
   } else {
     display=true;
+  }
   connect(okButton, SIGNAL(clicked()), this, SLOT(close()) );
   QHBoxLayout *hlayout = new QHBoxLayout;
   hlayout->addWidget(label);
   hlayout->addWidget(okButton);
   QVBoxLayout *layout = new QVBoxLayout;
   layout->addLayout(hlayout);
   layout->addWidget(show_again);
   setLayout(layout);
   setWindowTitle(title);
 };
 UniqueMessageBox::~UniqueMessageBox(void)  {
   if (show_again->checkState() == Qt::Checked ) {
     cerr << "Message won't be shown again\n";
     issued_messages << boxtext;
+  }
+}
 int UniqueMessageBox::exec(void)  {
   if (display)
     return QDialog::exec();
   else {
     return 1;
+  }
+}
 QStringList UniqueMessageBox::issued_messages;
 /* finis */

src/UniqueMessage.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _UNIQUEMESSAGE_H_
 #define _UNIQUEMESSAGE_H_
 #include <QDialog>
 #include <QCheckBox>
 #include <QStringList>
 #include <QLabel>
 class UniqueMessageBox : public QDialog {
   Q_OBJECT
  public:
   UniqueMessageBox ( /* Icon icon,*/
 		    const QString & title,
 		    const QString & text,
 		    /* StandardButtons buttons = Ok, */
 		    QWidget * parent = 0 , Qt::WindowFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint );
   ~UniqueMessageBox();
   int exec(void);
  private:
   static QStringList issued_messages;
   bool display;
   QCheckBox *show_again;
   QPushButton *okButton;
   QLabel *label;
   QString boxtext;
 };
 #endif
 /* finis */

src/VirtualLeaf.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <fstream>
 #include <sstream>
 #include <cstring>
 #include <functional>
 #include <getopt.h>
 #include <cerrno>
 #include "mesh.h"
 #include "parameter.h"
 #include "random.h"
 #include "pi.h"
 #include "cellitem.h"
 #include "canvas.h"
 #include "cell.h"
 #include "output.h"
 #include <qwidget.h>
 #include <q3process.h>
 #include <qapplication.h>
 #include <QDesktopWidget>
 #include <QGraphicsScene>
 #include <QMessageBox>
 //Added by qt3to4:
 #include <QMouseEvent>
 #include <unistd.h>
 #include <q3textstream.h>
 #ifdef HAVE_QWT
 #include "data_plot.h"
 #endif
 #include <QPalette>
 #include <QBrush>
 #include <QToolTip>
 #include "simplugin.h"
 #include <QPluginLoader>
 #include <QDir>
 #include "modelcatalogue.h"
 static const std::string _module_id("$Id$");
 extern Parameter par;
 MainBase *main_window = 0;
 #ifdef XFIGGRAPHICS
 #define TIMESTEP double Graphics::TimeStep(void)
 #endif
 class PrintNode {
 public:
   void operator() (const Node &n) const
+  {
     cerr << n.Index() << ": " << n <<  endl;
+  }
 };
 class EdgeSource {
 public:
   void operator() (Cell &c) {
     if (c.AtBoundaryP()) {
       cerr << "Cell " << c.Index() << " is a source cell.\n";
       c.SetSource(0,par.source);
     } else {
       cerr << "Cell " << c.Index() << " is _not_ a source cell.\n";
+    }
+  }
 };
 class CellInfo {
 public:
   void operator() (Cell &c,std::ostream &os) const {
     os << "Cell " << c.index << " says: " << endl;
     os << "c.nodes.size() = " << c.nodes.size() << endl;
     for (list<Node *>::iterator i=c.nodes.begin(); i!=c.nodes.end(); i++) {
       cerr << (*i)->Index() << " ";
+    }
     cerr << endl;
+  }
 };
 double PINSum(Cell &c) {
   return c.Chemical(1) + c.SumTransporters(1);// + c.ReduceCellAndWalls<double>( complex_PijAj );
+}
 class DrawCell {
 public:
   void operator() (Cell &c,QGraphicsScene &canvas, MainBase &m) const {
     if (m.ShowBorderCellsP() || c.Boundary()==Cell::None) {
       if (!m.ShowBoundaryOnlyP() && !m.HideCellsP()) {
 	if (m.ShowToolTipsP()) {
 	  QString info_string=QString("Cell %1, chemicals: ( %2, %3, %4, %5, %6)\n %7 of PIN1 at walls.\n Area is %8\n PIN sum is %9\n Circumference is %10\n Boundary type is %11").arg(c.Index()).arg(c.Chemical(0)).arg(c.Chemical(1)).arg(c.Chemical(2)).arg(c.Chemical(3)).arg(c.Chemical(4)).arg(c.SumTransporters(1)).arg(c.Area()).arg(PINSum(c)).arg(c.Circumference()).arg(c.BoundaryStr());
 	  info_string += "\n" + c.printednodelist();
 	  //QString info_string=QString("Cell %1, chemicals: ( %2, %3, %4, %5, %6)\n %7 of PIN1 at walls.\n Area is %8\n PIN sum is %9\n Circumference is %10\n Boundary type is %11").arg(c.Index()).arg(c.Chemical(0)).arg(c.Chemical(1)).arg(c.Chemical(2)).arg(c.Chemical(3)).arg(c.Chemical(4)).arg(c.SumTransporters(1)).arg(c.Area()).arg(PINSum(c)).arg(c.Circumference()).arg(c.BoundaryStr());
 		QString info_string=QString("Cell %1, chemicals(%2): ").arg(c.Index()).arg(Cell::NChem());
 		for (int i=0;i<Cell::NChem();i++) {
 			info_string += QString("%1 ").arg(c.Chemical(i));
+		}
 		info_string += QString("\nArea is %1\n Circumference is %2\n Boundary type is %3").arg(c.Area()).arg(c.Circumference()).arg(c.BoundaryStr());
 	  info_string += "\nNodes: " + c.printednodelist();
 	  c.Draw(&canvas, info_string);
 	} else {
 	  c.Draw(&canvas);
+	}
+      }
       if (m.ShowCentersP()){
 	c.DrawCenter(&canvas);
+      }
       if (m.ShowFluxesP()){
 	c.DrawFluxes(&canvas, par.arrowsize);
+      }
+    }
+  }
 };
 Mesh mesh;
 bool batch=false;
 void MainBase::Plot(int resize_stride)
+{
   clear();
   static int count=0;
   if (resize_stride) {
-    if ( !((++count)%resize_stride) ) {
     if ( !((count)%resize_stride) ) {
       FitLeafToCanvas();
+    }
+  }
   mesh.LoopCells(DrawCell(),canvas,*this);
   if (ShowNodeNumbersP())
     mesh.LoopNodes( bind2nd (mem_fun_ref ( &Node::DrawIndex), &canvas ) ) ;
   if (ShowCellNumbersP())
     mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawIndex), &canvas ) ) ;
   if (ShowCellAxesP())
     mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawAxis), &canvas ) );
   if (ShowCellStrainP())
     mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawStrain), &canvas ) );
   if (ShowWallsP())
     mesh.LoopWalls( bind2nd( mem_fun_ref( &Wall::Draw ), &canvas ) );
   if (ShowApoplastsP())
+/*  if (ShowApoplastsP())
     mesh.LoopWalls( bind2nd( mem_fun_ref( &Wall::DrawApoplast ), &canvas ) );
+*/
   if (ShowMeshP())
     mesh.DrawNodes(&canvas);
   if (ShowBoundaryOnlyP())
     mesh.DrawBoundary(&canvas);
   if ( ( batch || MovieFramesP() )) {
     static int frame = 0;
     // frame numbers are sequential for the most frequently written file type.
     // for the less frequently written file type they match the other type
     if (!(count%par.storage_stride) )  {
       stringstream fname;
       fname << par.datadir << "/leaf.";
       fname.fill('0');
       fname.width(6);
       fname << frame << ".jpg";
       if (par.storage_stride <= par.xml_storage_stride) {
 	frame++;
+      }
       // Write high-res JPG snapshot every plot step
       Save(fname.str().c_str(), "JPEG",1024,768);
+    }
     if (!(count%par.xml_storage_stride)) {
       stringstream fname;
       fname << par.datadir << "/leaf.";
       fname.fill('0');
       fname.width(6);
       fname << frame << ".xml";
       if (par.xml_storage_stride < par.storage_stride) {
 	frame++;
+      }
       // Write XML file every ten plot steps
       mesh.XMLSave(fname.str().c_str(), XMLSettingsTree());
+    }
+  }
  count++;
+}
 INIT {
   //mesh.SetSimPlugin(plugin);
   if (leaffile) {
     xmlNode *settings;
     mesh.XMLRead(leaffile, &settings);
     main_window->XMLReadSettings(settings);
     xmlFree(settings);
     main_window->UserMessage(QString("Ready. Time is %1").arg(mesh.getTimeHours().c_str()));
   } else {
     mesh.StandardInit();
+  }
+}
 TIMESTEP {
   static int i=0;
   static int t=0;
   static int ncells;
   if (!batch) {
     UserMessage(QString("Time: %1").arg(mesh.getTimeHours().c_str()),0);
+  }
   ncells=mesh.NCells();
   double dh;
   if(DynamicCellsP()) {
     dh = mesh.DisplaceNodes();
     // Only allow for node insertion, cell division and cell growth
     // if the system has equillibrized
     // i.e. cell wall tension equillibrization is much faster
     // than biological processes, including division, cell wall yielding
     // and cell expansion
     mesh.InsertNodes(); // (this amounts to cell wall yielding)
     if ( (-dh) < par.energy_threshold) {
       mesh.IncreaseCellCapacityIfNecessary();
       mesh.DoCellHouseKeeping();
       //mesh.LoopCurrentCells(mem_fun(&plugin->CellHouseKeeping)); // this includes cell division
       // Reaction diffusion
       mesh.ReactDiffuse(par.rd_dt);
       t++;
       Plot(par.resize_stride);
+    }
   } else {
     mesh.ReactDiffuse(par.rd_dt);
     Plot(par.resize_stride);
+  }
   i++;
   return mesh.getTime();
+}
 /* Called if a cell is clicked */
 void Cell::OnClick(QMouseEvent *e){}
 /* Custom message handler - Default appends a newline character to the end of each line. */
 void vlMessageOutput(QtMsgType type, const char *msg)
+{
   switch (type) {
   case QtDebugMsg:
     //fprintf(stderr, "Debug: %s\n", msg);
     cerr << msg << flush;
     break;
   case QtWarningMsg:
     //fprintf(stderr, "Warning: %s\n", msg);
     cerr << "Warning: " << msg << flush;
     break;
   case QtCriticalMsg:
     fprintf(stderr, "Critical: %s\n", msg);
     cerr << "Critical: " << msg << flush;
     break;
   case QtFatalMsg:
     //fprintf(stderr, "Fatal: %s\n", msg);
     cerr << "Fatal: " << msg << flush;
     abort();
+  }
+}
 Parameter par;

src/VirtualLeaf.pro

➞

Show inline comments

+#
 #  $Id$
+#
 #  This file is part of the Virtual Leaf.
+#
 #  The Virtual Leaf is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation, either version 3 of the License, or
 #  (at your option) any later version.
+#
 #  The Virtual Leaf is distributed in the hope that it will be useful,
 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #  GNU General Public License for more details.
+#
 #  You should have received a copy of the GNU General Public License
 #  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+#
 #  Copyright 2010 Roeland Merks.
+#
 CONFIG += release
 CONFIG -= debug
 CONFIG += qt
 QMAKE_CXXFLAGS += -fexceptions
 QMAKE_CXXFLAGS += -Wall
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 #REACTIONS = reactions_auxin_growth.h
 #REACTIONS = reactions_meinhardt.h
 #REACTIONS = reactions_pce_growth.h
 DEFINES += QTGRAPHICS
 DEFINES += REACTIONS_HEADER=$${REACTIONS}
 DEFINES += REACTIONS_HEADER_STRING=\"$${REACTIONS}\"
 DEFINES += FLEMING
 BINDIR = ../bin
 DESTDIR = $$BINDIR
 TARGET = VirtualLeaf
 TEMPLATE = app
 PARTMPL = $${TARGET}par.tmpl
 MAINSRC = $${TARGET}.cpp
 QT -= network sql xml
 QT += qt3support
 !win32 {
  GRAPHICS = qt #qwt
+}
 win32 {
  CONFIG -= console
  LIBXML2DIR = ..\lib\libxml2
  LIBICONVDIR = ..\lib\libiconv
  LIBZDIR = ..\lib\libz
  LIBXML2DIR = C:
  LIBICONVDIR = C:
  LIBZDIR = C:
  GRAPHICS = qt
  RC_FILE = VirtualLeaf.rc
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
+# QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
  LIBS += -L$${LIBXML2DIR}\lib -lxml2 -L$${LIBICONVDIR}\lib -L$${LIBZDIR}\lib  -lz -lm -lwsock32 -liconv
+}
 macx:release {
  LIBS+= -dead_strip
+}
 unix {
  CC = /usr/bin/gcc
  QWTDIR = /ufs/guravage/opt/qwt-5.2.1-svn
  QMAKE_LIBDIR += $$QWTDIR/lib
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
  LIBS += -lxml2 -lz -lm
+}
 # Input
 HEADERS += \
  apoplastitem.h \
+# apoplastitem.h \
  canvas.h \
  cellbase.h \
  cell.h \
  cellitem.h \
  forwardeuler.h \
  infobar.h \
  mainbase.h \
  mainbase.h \
  matrix.h \
  mesh.h \
  miscq.h \
  modelcatalogue.h \
  Neighbor.h \
  node.h \
  nodeitem.h \
  nodeset.h \
  OptionFileDialog.h \
  output.h \
  parameter.h \
  pardialog.h \
  parse.h \
  pi.h \
  qcanvasarrow.h \
  random.h \
  rungekutta.h \
  simitembase.h \
  simplugin.h \
  sqr.h \
  tiny.h \
  transporterdialog.h \
  UniqueMessage.h \
  vector.h \
  wallbase.h \
  wall.h \
  wallitem.h \
  warning.h \
  xmlwrite.h \
  $${PARTMPL}
 SOURCES += \
  apoplastitem.cpp \
+# apoplastitem.cpp \
  canvas.cpp \
  cellbase.cpp \
  cell.cpp \
  cellitem.cpp \
  forwardeuler.cpp \
  mainbase.cpp \
  matrix.cpp \
  mesh.cpp \
  miscq.cpp \
  modelcatalogue.cpp \
  Neighbor.cpp \
  node.cpp \
  nodeitem.cpp \
  nodeset.cpp \
  OptionFileDialog.cpp \
  output.cpp \
  parameter.cpp \
  pardialog.cpp \
  parse.cpp \
  random.cpp \
  rungekutta.cpp \
  simitembase.cpp \
  transporterdialog.cpp \
  UniqueMessage.cpp \
  vector.cpp \
  wallbase.cpp \
  wall.cpp \
  wallitem.cpp \
  warning.cpp \
  xmlwrite.cpp \
  $$MAINSRC
 contains( TARGET, leaf_fleming ) {
  DEFINES += FLEMING
+}
 contains(GRAPHICS, qwt) {
  #macx:LIBS += -L$$QWTDIR/lib -lqwt
  #win32:LIBS += -L$$QWTDIR/lib -lqwt5
  #LIBS += -L$$QWTDIR/lib -lqwt
  INCLUDEPATH += $$QWTDIR/include
  DEFINES += HAVE_QWT
  HEADERS += data_plot.h
  SOURCES += data_plot.cpp
+}
 contains( GRAPHICS, qt ) {
  message( "Building Qt executable" )
  QMAKE_CXXFLAGS += -DQTGRAPHICS # -fpermissive
+}
 contains( GRAPHICS, xfig ) {
  message("Building Xfig executable (background runnable).")
  QMAKE_CXXFLAGS += -DXFIGGRAPHICS
+}
 contains( GRAPHICS, x11 ) {
  !unix {
   error("X11 graphics only available on Unix systems.")
+ }
  message("Building X11 executable")
  SOURCES += x11graph.cpp
  HEADERS += x11graph.h
  QMAKE_CXXFLAGS += -DX11GRAPHICS
  CONFIG -= qt
  CONFIG += x11
  unix:LIBS += -lpng
+}
 #contains( GRAPHICS, qwt ) {
 # 	QMAKE_POST_LINK = "install_name_tool -change libqwt.5.dylib $$QWTDIR/lib/libqwt.dylib $${TARGET}.app/Contents/MacOS/$${TARGET}; \
 #}
 # MACOSX packaging
 macx {
 ICON = leaficon.icns
 QMAKE_POST_LINK = "\
 	#install_name_tool -change libqwt.5.dylib $$QWTDIR/lib/libqwt.dylib $${TARGET}.app/Contents/MacOS/$${TARGET}; \
 	cp leaficon.icns $${DESTDIR}/$${TARGET}.app; \
 	mkdir $${DESTDIR}/$${TARGET}.app/Contents/Frameworks; \
 	cp -R /Library/Frameworks/QtCore.framework $${DESTDIR}/$${TARGET}.app/Contents/Frameworks; \
 	cp -R /Library/Frameworks/QtGui.framework $${DESTDIR}/$${TARGET}.app/Contents/Frameworks; \
 	cp -R /Library/Frameworks/Qt3Support.framework $${DESTDIR}/$${TARGET}.app/Contents/Frameworks; \
 	#cp /usr/local/qwt/lib/libqwt.dylib $${DESTDIR}/$${TARGET}.app/Contents/Frameworks; \
 	#install_name_tool -id @executable_path/../Frameworks/libqwt.dylib $${DESTDIR}/$${TARGET}.app/Contents/Frameworks/libqwt.dylib; \
 	install_name_tool -change /usr/local/qwt/lib/libqwt.dylib @executable_path/../Frameworks/libqwt.dylib $${DESTDIR}/$${TARGET}.app/Contents/MacOS/$${TARGET};\
 	install_name_tool -id @executable_path/../Frameworks/QtCore.framework/Versions/Current/QtCore $${DESTDIR}/$${TARGET}.app/Contents/Frameworks/QtCore.framework/Versions/4.0/QtCore; \
 	install_name_tool -id @executable_path/../Frameworks/QtGui.framework/Versions/Current/QtGui $${DESTDIR}/$${TARGET}.app/Contents/Frameworks/QtGui.framework/Versions/4.0/QtGui; \
 	install_name_tool -id @executable_path/../Frameworks/Qt3Support.framework/Versions/Current/Qt3Support $${DESTDIR}/$${TARGET}.app/Contents/Frameworks/Qt3Support.framework/Versions/4.0/Qt3Support; \
 	install_name_tool -change Frameworks/QtCore.framework/Versions/Current/QtCore @executable_path/../Frameworks/QtCore.framework/Versions/4.0/QtCore $${DESTDIR}/$${TARGET}.app/Contents/MacOS/$${TARGET}; \
 	install_name_tool -change Frameworks/QtGui.framework/Versions/Current/QtGui @executable_path/../Frameworks/QtGui.framework/Versions/4.0/QtGui $${DESTDIR}/$${TARGET}.app/Contents/MacOS/$${TARGET}; \
 	install_name_tool -change Frameworks/Qt3Support.framework/Versions/Current/Qt3Support @executable_path/../Frameworks/Qt3Support.framework/Versions/4.0/Qt3Support $${DESTDIR}/$${TARGET}.app/Contents/MacOS/$${TARGET}; \
 	install_name_tool -change Frameworks/QtCore.framework/Versions/Current/QtCore @executable_path/../Frameworks/QtCore.framework/Versions/4.0/QtCore $${DESTDIR}/$${TARGET}.app/Contents/Frameworks/Qt3Support.framework/Versions/4.0/Qt3Support; \
 	install_name_tool -change Frameworks/QtGui.framework/Versions/Current/QtGui @executable_path/../Frameworks/QtGui.framework/Versions/4.0/QtGui $${DESTDIR}/$${TARGET}.app/Contents/Frameworks/Qt3Support.framework/Versions/4.0/Qt3Support; \
 	install_name_tool -change Frameworks/QtCore.framework/Versions/Current/QtCore @executable_path/../Frameworks/QtCore.framework/Versions/4.0/QtCore $${DESTDIR}/$${TARGET}.app/Contents/Frameworks/Qt3Support.framework/Versions/4.0/Qt3Support; "
+}

src/build_models/plugin_auxingrowth.pro

➞

Show inline comments

+#
 # $Id$
+#
 #  This file is part of the Virtual Leaf.
+#
 #  The Virtual Leaf is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation, either version 3 of the License, or
 #  (at your option) any later version.
+#
 #  The Virtual Leaf is distributed in the hope that it will be useful,
 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #  GNU General Public License for more details.
+#
 #  You should have received a copy of the GNU General Public License
 #  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+#
 #  Copyright 2010 Roeland Merks.
+#
 CONFIG += release
 CONFIG -= debug
 CONFIG += plugin
 BINDIR = ../../bin
 LIBDIR = ../../lib
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = $${BINDIR}/models
 TARGET = auxingrowth
 HEADERS = ../simplugin.h $${TARGET}plugin.h
 QMAKE_CXXFLAGS += -fexceptions -I..
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QT += qt3support
 SOURCES = $${TARGET}plugin.cpp
 TEMPLATE = lib
 unix {
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = ..\..\lib\libxml2
  LIBICONVDIR = ..\..\lib\libiconv
  LIBZDIR = ..\..\lib\libz
  LIBXML2DIR = $${LIBDIR}\lib\libxml2
  LIBICONVDIR = $${LIBDIR}\lib\libiconv
  LIBZDIR = $${LIBDIR}\lib\libz
  LIBS += -L$${LIBDIR} -Llib -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finis

src/build_models/plugin_meinhardt.pro

➞

Show inline comments

+#
 # $Id$
+#
 #  This file is part of the Virtual Leaf.
+#
 #  The Virtual Leaf is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation, either version 3 of the License, or
 #  (at your option) any later version.
+#
 #  The Virtual Leaf is distributed in the hope that it will be useful,
 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #  GNU General Public License for more details.
+#
 #  You should have received a copy of the GNU General Public License
 #  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+#
 #  Copyright 2010 Roeland Merks.
+#
 CONFIG += release
 CONFIG -= debug
 CONFIG += plugin
 BINDIR = ../../bin
 LIBDIR = ../../lib
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = $${BINDIR}/models
 TARGET = meinhardt
 HEADERS = ../simplugin.h $${TARGET}plugin.h
 QMAKE_CXXFLAGS += -fexceptions -I..
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QT += qt3support
 SOURCES = $${TARGET}plugin.cpp
 TEMPLATE = lib
 unix {
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = ..\..\lib\libxml2
  LIBICONVDIR = ..\..\lib\libiconv
  LIBZDIR = ..\..\lib\libz
  LIBXML2DIR = $${LIBDIR}\lib\libxml2
  LIBICONVDIR = $${LIBDIR}\lib\libiconv
  LIBZDIR = $${LIBDIR}\lib\libz
  LIBS += -L$${LIBDIR} -Llib -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finis

src/build_models/plugin_test.pro

➞

Show inline comments

+#
 # $Id$
+#
 #  This file is part of the Virtual Leaf.
+#
 #  The Virtual Leaf is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation, either version 3 of the License, or
 #  (at your option) any later version.
+#
 #  The Virtual Leaf is distributed in the hope that it will be useful,
 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #  GNU General Public License for more details.
+#
 #  You should have received a copy of the GNU General Public License
 #  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+#
 #  Copyright 2010 Roeland Merks.
+#
 CONFIG += release
 CONFIG -= debug
 CONFIG += plugin
 BINDIR = ../../bin
 LIBDIR = ../../lib
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = $${BINDIR}/models
 TARGET = test
 HEADERS = ../simplugin.h $${TARGET}plugin.h
 QMAKE_CXXFLAGS += -fexceptions -I..
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QT += qt3support
 SOURCES = $${TARGET}plugin.cpp
 TEMPLATE = lib
 unix {
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = ..\..\lib\libxml2
  LIBICONVDIR = ..\..\lib\libiconv
  LIBZDIR = ..\..\lib\libz
  LIBXML2DIR = $${LIBDIR}\lib\libxml2
  LIBICONVDIR = $${LIBDIR}\lib\libiconv
  LIBZDIR = $${LIBDIR}\lib\libz
  LIBS += -L$${LIBDIR} -Llib -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finis

src/canvas.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <fstream>
 #include <streambuf>
 #include <QGraphicsScene>
 #include <QGraphicsView>
 #include <qdatetime.h>
 #include <q3mainwindow.h>
 #include <qstatusbar.h>
 #include <qmessagebox.h>
 #include <qmenubar.h>
 #include <qapplication.h>
 #include <qpainter.h>
 #include <qprinter.h>
 #include <qlabel.h>
 #include <qimage.h>
 #include <q3progressdialog.h>
 #include <qtimer.h>
 #include <qslider.h>
 #include <qpixmap.h>
 #include <qfile.h>
 #include <qdir.h>
 #include <q3filedialog.h>
 #include <QGraphicsItem>
 #include <QList>
 #include <QDir>
 #include <QDebug>
 #include <set>
 //Added by qt3to4:
 #include <Q3ValueList>
 #include <Q3PopupMenu>
 #include <QMouseEvent>
 #include <typeinfo>
 #include <cstring>
 #include <q3process.h>
 #include <qlayout.h>
 #include <qspinbox.h>
 #include <fstream>
 #include <sstream>
 #include "pardialog.h"
 #include "parameter.h"
 #include "canvas.h"
 #include "node.h"
 #include "nodeset.h"
 #include "nodeitem.h"
 #include "cellitem.h"
 #include "wallitem.h"
 #include "mesh.h"
 #include "xmlwrite.h"
 #include "miscq.h"
 #include "OptionFileDialog.h"
 #include <cstdlib>
 #include <cstdio>
 #include "modelcatalogue.h"
 #include <algorithm>
 // Include VIB and PSB logos
 #include "psb.xpm"
 #include "cwi.xpm"
 static const std::string _module_id("$Id$");
 // We use a global variable to save memory - all the brushes and pens in
 // the mesh are shared.
 #define QUOTE_ME(s) QUOTE_ME_2NDLEV(s)
 #define QUOTE_ME_2NDLEV(s) #s
 static QColor dark_red("darkRed");
 static const int imageRTTI = 984376;
 extern Parameter par;
 const QString Main::caption("Virtual leaf");
 const QString Main::caption_with_file("Virtual leaf: %1");
 FigureEditor::FigureEditor(
 			   QGraphicsScene& c, Mesh &m, QWidget* parent,
 			   const char* name, Qt::WindowFlags f) :
   QGraphicsView(&c,parent), mesh(m)
+{
   intersection_line = 0;
@@ @@ -430,230 +430,231 @@ NodeItem *FigureEditor::selectedNodeItem @@
       // indicate we've selected it
       nodeItem->setBrush(dark_red);
       break;
+    }
+  }
   return nodeItem;
+}
 void FigureEditor::insertNode(QPointF p)
+{
   Node *node = new Node(p.x(), p.y(), 0);
   mesh.AddNode(node);
   scene()->clearSelection();
   dynamic_cast<Main *>(parent())->Plot();
   FullRedraw();
 #ifdef QDEBUG
   qDebug() << "Node: " << p << endl;
 #endif
+}
 static uint mainCount = 0;
 Main::Main(QGraphicsScene& c, Mesh &m, QWidget* parent, const char* name, Qt::WindowFlags f) :
   Q3MainWindow(parent,name,f),
   MainBase(c,m),
   mesh(m)
+{
   editor = new FigureEditor(canvas,mesh, this);
 #ifdef QDEBUG
   qDebug() << "Interactive = " << editor->isEnabled();
 #endif
   working_dir = 0;
   QObject::connect( editor, SIGNAL(MousePressed()), this, SLOT(PauseIfRunning()));
   QObject::connect( editor, SIGNAL(MouseReleased()), this, SLOT(ContIfRunning()));
   QMenuBar* menu = menuBar();
   Q3PopupMenu* file = new Q3PopupMenu( menu );
   file->insertItem("&Read leaf", this, SLOT(readStateXML()));
   file->insertItem("&Save leaf", this, SLOT(saveStateXML()));
   file->insertItem("Snapshot", this, SLOT(snapshot()), Qt::CTRL+Qt::SHIFT+Qt::Key_S);
   file->insertSeparator();
   file->insertItem("Read next leaf", this, SLOT(readNextStateXML()), Qt::Key_PageDown);
   file->insertItem("Read previous leaf", this, SLOT(readPrevStateXML()), Qt::Key_PageUp);
   file->insertItem("Read last leaf", this, SLOT(readLastStateXML()), Qt::Key_End);
   file->insertItem("Read first leaf", this, SLOT(readFirstStateXML()), Qt::Key_Home);
   file->insertSeparator();
   file->insertItem("&Print...", this, SLOT(print()), Qt::CTRL+Qt::Key_P);
   file->insertSeparator();
   file->insertItem("E&xit", qApp, SLOT(quit()), Qt::CTRL+Qt::Key_Q);
   menu->insertItem("&File", file);
   Q3PopupMenu* edit = new Q3PopupMenu( menu );
   edit->insertItem("Reset Chemicals and Transporters", this, SLOT( CleanMesh()), Qt::CTRL+Qt::Key_R );
   edit->insertItem("Reset Chemicals", this, SLOT( CleanMeshChemicals()) );
   edit->insertItem("Reset Transporters", this, SLOT( CleanMeshTransporters()) );
   edit->insertItem("Randomize PIN1 Transporters", this, SLOT( RandomizeMesh()) );
   edit->insertItem("Cut away SAM", this, SLOT( CutSAM() ));
   menu->insertItem("&Edit", edit);
   run = new Q3PopupMenu( menu );
   running = false;
   paused_id = run->insertItem("&Simulation paused", this, SLOT(togglePaused()), Qt::Key_S);
   run->setItemChecked(paused_id, FALSE);
   menu->insertItem("&Run", run);
   view = new Q3PopupMenu( menu );
   view->insertItem("&Zoom in", this, SLOT(zoomIn()), Qt::CTRL+Qt::Key_Equal);
   view->insertItem("Zoom &out", this, SLOT(zoomOut()), Qt::CTRL+Qt::Key_Minus);
   view->insertSeparator();
   com_id = view->insertItem("Show cell &centers", this, SLOT(toggleShowCellCenters()));
   view->setItemChecked(com_id, FALSE);
   mesh_id = view->insertItem("Show &nodes", this, SLOT(toggleShowNodes()), Qt::CTRL+Qt::SHIFT+Qt::Key_N);
   view->setItemChecked(mesh_id, TRUE);
   node_number_id = view->insertItem("Show node numbers", this, SLOT(toggleNodeNumbers()), Qt::CTRL+Qt::SHIFT+Qt::Key_M);
   view->setItemChecked(node_number_id, FALSE);
   cell_number_id = view->insertItem("Show cell numbers", this, SLOT(toggleCellNumbers()));
   view->setItemChecked(cell_number_id, FALSE);
   hide_cells_id = view->insertItem("Hide cells", this, SLOT(toggleHideCells()));
   view->setItemChecked(hide_cells_id, FALSE);
   border_id = view->insertItem("Show &border cells", this, SLOT(toggleShowBorderCells()));
   view->setItemChecked(border_id, FALSE);
   cell_axes_id = view->insertItem("Show cell &axes", this, SLOT(toggleCellAxes()));
   cell_strain_id = view->insertItem("Show cell &strain", this, SLOT(toggleCellStrain()));
   view->setItemChecked(cell_axes_id, FALSE);
   fluxes_id = view->insertItem("Show &fluxes", this, SLOT(toggleShowFluxes()));
   view->setItemChecked(fluxes_id, FALSE);
   cell_walls_id = view->insertItem("Show transporters", this, SLOT(toggleShowWalls()));
   view->setItemChecked(cell_walls_id, FALSE);
   apoplasts_id = view->insertItem("Show apoplasts", this, SLOT(toggleShowApoplasts()));
   view->setItemChecked(apoplasts_id, FALSE);
  // apoplasts_id = view->insertItem("Show apoplasts", this, SLOT(toggleShowApoplasts()));
  // view->setItemChecked(apoplasts_id, FALSE);
   view->insertSeparator();
   only_boundary_id = view->insertItem("Show only leaf &boundary", this, SLOT(toggleLeafBoundary()));
   view->insertSeparator();
   movie_frames_id = view->insertItem("Start saving movie &frames", this, SLOT(toggleMovieFrames()));
   view->setItemChecked(movie_frames_id, par.movie);
   view->setItemChecked(only_boundary_id, FALSE);
   menu->insertItem("&View", view);
   options = new Q3PopupMenu( menu );
   dyn_cells_id = options->insertItem("Cell growth", this, SLOT(toggleDynCells()));
   options->setItemChecked(dyn_cells_id, true);
   options->insertItem("Edit &parameters", this, SLOT(EditParameters()), Qt::CTRL+Qt::Key_E);
   rotation_mode_id = options->insertItem("Rotate leaf", this, SLOT(EnterRotationMode()), Qt::CTRL + Qt::SHIFT + Qt::Key_R);
   options->setItemChecked(rotation_mode_id, false);
   menu->insertItem("&Options",options);
   // Menu of models
   modelmenu = new QMenu( menu );
   menu->insertItem("&Models", modelmenu);
   menu->insertSeparator();
   helpmenu = new Q3PopupMenu( menu );
   tooltips_id = helpmenu->insertItem("Show Cell&Info", this, SLOT(Refresh()));
   helpmenu->setItemChecked(tooltips_id, true);
   helpmenu->insertSeparator();
   helpmenu->insertItem("&About", this, SLOT(about()) ); //, Key_F1);
   helpmenu->insertSeparator();
     //helpmenu->insertSeparator();
   helpmenu->insertItem("&LICENSE", this, SLOT(gpl()) );
   menu->insertItem("&Help",helpmenu);
   helpmenu->insertItem("About", this, SLOT(about()) ); //, Key_F1);
 	menu->insertItem("&Help",helpmenu);
   statusBar();
   setCentralWidget(editor);
   printer = 0;
   init();
   // Start timer which repetitively invokes
   // a simulation time step
   timer = new QTimer( this );
   connect( timer, SIGNAL(timeout()), SLOT(TimeStepWrap()) );
   stopSimulation();
   statusBar()->addWidget(new QLabel("Ready."));
   setCaption(caption);
   gifanim = 0;
   infobar = new InfoBar();
   addDockWindow(infobar);
+}
 void Main::RefreshInfoBar(void)
+{
   infobar->SetText(mesh.ModelID());
+}
 void Main::UserMessage(QString message, int timeout)
+{
   statusBar()->showMessage(message, timeout);
+}
 void Main::init()
+{
   clear();
   static int r=24;
   srand(++r);
   mainCount++;
+}
 Main::~Main()
+{
   delete printer;
   if ( !--mainCount ) {
+  }
   //EndGifAnim();
+}
 void Main::newView()
+{
   // Open a new view... have it delete when closed.
   Main *m = new Main(canvas, mesh, 0, 0, Qt::WDestructiveClose);
   qApp->setMainWidget(m);
   m->show();
   qApp->setMainWidget(0);
+}
 void Main::EditParameters()
+{
   ParameterDialog *pardial = new ParameterDialog(this, "stridediag");
   // Make sure the values in the parameter dialog are updated after a file is read
   // each method changing the parameters (reading XML or PAR files) should
   // emit this signal
   QObject::connect(   this, SIGNAL( ParsChanged() ), pardial, SLOT( Reset() ) );
+}
 void Main::savePars()
+{
   stopSimulation();
   Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );
   fd->setMode( Q3FileDialog::AnyFile );
   fd->setFilter( "Parameter files (*.par)");
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     ofstream parfile((const char *)fileName);
     par.Write(parfile);
+  }
   startSimulation();
+}
 void Main::readPars()
+{
   stopSimulation();
   Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );
   fd->setMode( Q3FileDialog::ExistingFile );
@@ @@ -835,202 +836,202 @@ void Main::readNextStateXML() @@
     if (f==xml_files.end()) {
       QMessageBox mb( "Read next leaf",
 		      "No more files",
 		      QMessageBox::Information,
 		      QMessageBox::Ok | QMessageBox::Default,
 		      QMessageBox::NoButton,
 		      QMessageBox::NoButton);
       mb.exec();
       return;
+    }
     next_file = *f;
     next_file = currentFile_path+"/"+next_file;
     readStateXML((const char*)next_file);
+  }
+}
 void Main::readLastStateXML()
+{
   // if we have already read a file, read the next file
   if (!currentFile.isEmpty() && working_dir) {
     QString next_file;
     QStringList xml_files = working_dir->entryList("*.xml");
     QString currentFile_nopath = currentFile.section( '/', -1 );
     QString currentFile_path = currentFile.section( '/', 0, -2 );
     next_file = xml_files.back();
     next_file = currentFile_path+"/"+next_file;
     readStateXML((const char*)next_file);
+  }
+}
 void Main::readFirstStateXML()
+{
   // if we have already read a file, read the next file
   if (!currentFile.isEmpty() && working_dir) {
     QString next_file;
     QStringList xml_files = working_dir->entryList("*.xml");
     QString currentFile_nopath = currentFile.section( '/', -1 );
     QString currentFile_path = currentFile.section( '/', 0, -2 );
     next_file = xml_files.front();
     next_file = currentFile_path+"/"+next_file;
     readStateXML((const char*)next_file);
+  }
+}
 void Main::readStateXML()
+{
   //  extern Mesh mesh;
   stopSimulation();
 #ifdef QDEBUG
   qDebug() << "Trying to open an OptionFileDialog" << endl;
 #endif
   OptionFileDialog *fd = new OptionFileDialog( this, "read dialog", TRUE );
   fd->setMode( OptionFileDialog::ExistingFile );
   fd->setFilter( "XML files (*.xml)");
   if (working_dir) {
     fd->setDir(*working_dir);
+  }
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     if (working_dir) {
       delete working_dir;
+    }
     working_dir = fd->dir();
     if (readStateXML((const char *)fileName,fd->readGeometryP(), fd->readParametersP()) )
       return readStateXML(); // user can try again
+  }
+}
 void Main::clear()
+{
   editor->clear();
+}
 void Main::about()
+{
   static QMessageBox* about = new QMessageBox
     ( "Virtual Leaf V1.0",
       "<h3>Virtual Leaf V1.0</h3>"
     ( "VirtualLeaf V1.0",
       "<h3>VirtualLeaf V1.0</h3>"
       "<p>"
       "An Open Source framework for cell-based modeling of plant tissue growth and development <br>"
       "(c) 2005-2008, Roeland Merks <i>et al.</i><br>"
       "    <a href=\"http://www.psb.vib-ugent.be\">VIB Department Plant Systems Biology</a>, "
       "Ghent, Belgium <br>"
       "(c) 2008-2010, <a href=\"http://www.cwi.nl/~merks\">Roeland Merks <i>et al.</i></a> <br>"
       "    <a href=\"http://www.cwi.nl\">Centrum Wiskunde & Informatica</a> and <a href=\"http://www.ncsb.nl\">Netherlands Consortium for Systems Biology</a>, Amsterdam, Netherlands <br>"
-"<br>The Virtual Leaf is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.<br>"
+"<br>VirtualLeaf is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.<br>"
       "<br>If you use this code for your projects, please cite our paper:"
 "<br>Merks, Guravage, Inze, and Beemster. An Open Source framework for cell-based modeling of plant tissue growth and development. <i>Plant Physiology,</i> submitted.<br> . <br>"
       "<br>Please share your model plugins and extensions at <a href=\"http://virtualleaf.googlecode.com\">http://virtualleaf.googlecode.com</a>.",
       QMessageBox::Information, 1, 0, 0, this, 0, FALSE );
   about->setButtonText( 1, "Dismiss" );
   about->show();
+}
 void Main::gpl()
+{
   static QMessageBox* gpl = new QMessageBox ( "GPL License", "",
       QMessageBox::Information, 1, 0, 0, this, 0, FALSE );
   QDir docDir(QApplication::applicationDirPath());
   docDir.cd("../doc");
   QString path = docDir.filePath("gpl3.txt");
   std::ifstream file(path.toStdString().c_str());
   std::string str;
   if (file) {
     file.seekg(0, std::ios::end);
     str.reserve(file.tellg());
     file.seekg(0, std::ios::beg);
     str.assign((std::istreambuf_iterator<char>(file)),
 	       std::istreambuf_iterator<char>());
     gpl->setDetailedText(QString(str.c_str()));
+  }
   gpl->setText(QString( "<h3>GNU GENERAL PUBLIC LICENSE</h3>"
 			"<p>Version 3, 29 June 2007</p>"
 			"<p>Copyright &copy; 2007 Free Software Foundation, Inc. "
 			"&lt;<a href=\"http://fsf.org/\">http://fsf.org/</a>&gt;</p><p>"
 			"Everyone is permitted to copy and distribute verbatim copies "
 			"of this license document, but changing it is not allowed.</p>"
 			"<h2>GNU GENERAL PUBLIC LICENSE</h2>"));
   gpl->setButtonText( 1, "Dismiss" );
   gpl->show();
+}
 void Main::aboutQt(){
   QMessageBox::aboutQt( this, "Virtual Leaf" );
+}
 void Main::toggleShowCellCenters()
+{
   Plot();
+}
 void Main::toggleShowWalls()
+{
   Plot();
+}
 void Main::toggleShowApoplasts()
+{
   Plot();
+}
 void Main::toggleShowNodes()
+{
   Plot();
+}
 void Main::toggleNodeNumbers(void)
+{
   Plot();
+}
 void Main::toggleCellNumbers(void)
+{
   Plot();
+}
 void Main::toggleCellAxes(void)
+{
   Plot();
+}
 void Main::toggleCellStrain(void)
+{
   Plot();
+}
 void Main::toggleShowFluxes(void)
+{
   Plot();
+}
 void Main::toggleShowBorderCells()
+{
   Plot();
@@ @@ -1231,126 +1232,126 @@ void Main::FitLeafToCanvas(void) @@
   QRectF bb( ll.x - border.x, ll.y - border.y, ur.x-ll.x + 2*border.x, ur.y-ll.y + 2*border.y );
   // cerr << ur << ", " << ll << endl;
   // editor->fitInView(bb, Qt::KeepAspectRatio);
   editor->ensureVisible(bb);
   //editor->setTransform(viewport);
+}
 void Main::CleanMesh(void)
+{
   vector<double> clean_chem(Cell::NChem());
   vector<double> clean_transporters(Cell::NChem());
   for (int i=0;i<Cell::NChem();i++) {
     clean_chem[i]=par.initval[i];
     clean_transporters[i]=0.;
+  }
   mesh.CleanChemicals(clean_chem);
   mesh.CleanTransporters(clean_transporters);
   mesh.setTime(0);
   Plot();
   editor->FullRedraw();
+}
 void Main::CleanMeshChemicals(void)
+{
   vector<double> clean_chem(Cell::NChem());
   for (int i=0;i<Cell::NChem();i++) {
     clean_chem[i]=par.initval[i];
+  }
   mesh.CleanChemicals(clean_chem);
   mesh.setTime(0);
   Plot();
   editor->FullRedraw();
+}
 void Main::CleanMeshTransporters(void)
+{
   vector<double> clean_transporters(Cell::NChem());
   for (int i=0;i<Cell::NChem();i++) {
     clean_transporters[i]=0.;
+  }
   mesh.CleanTransporters(clean_transporters);
   mesh.setTime(0);
   Plot();
   editor->FullRedraw();
+}
 void Main::RandomizeMesh(void)
+{
   vector<double> max_chem(Cell::NChem());
   vector<double> max_transporters(Cell::NChem());
   for (int i=0;i<Cell::NChem();i++) {
     max_transporters[i]=0.;
     max_chem[i]=par.initval[i];
+  }
   // Amount of PIN1 at walls
   max_transporters[1] = 0.01;
   mesh.RandomizeChemicals(max_chem, max_transporters);
   Plot();
+}
 void Main::XMLReadSettings(xmlNode *settings)
+{
   MainBase::XMLReadSettings(settings);
   view->setItemChecked(com_id, showcentersp);
   view->setItemChecked(mesh_id, showmeshp);
   view->setItemChecked(border_id, showbordercellp);
   view->setItemChecked(node_number_id, shownodenumbersp);
   view->setItemChecked(cell_number_id, showcellnumbersp);
   view->setItemChecked(cell_axes_id, showcellsaxesp);
   view->setItemChecked(cell_strain_id, showcellstrainp);
   view->setItemChecked(movie_frames_id, movieframesp);
   view->setItemChecked(only_boundary_id, showboundaryonlyp);
   view->setItemChecked(fluxes_id, showfluxesp);
   view->setItemChecked(hide_cells_id, hidecellsp);
   options->setItemChecked(dyn_cells_id, dynamicscellsp);
   view->setItemChecked( cell_walls_id, showwallsp);
   view->setItemChecked( apoplasts_id, showapoplastsp);
+ // view->setItemChecked( apoplasts_id, showapoplastsp);
   editor->setTransform(viewport);
+}
 xmlNode *Main::XMLSettingsTree(void)
+{
   showcentersp = view->isItemChecked(com_id);
   showmeshp = view->isItemChecked(mesh_id);
   showbordercellp =  view->isItemChecked(border_id);
   shownodenumbersp =  view->isItemChecked(node_number_id);
   showcellnumbersp =  view->isItemChecked(cell_number_id);
   showcellsaxesp = view->isItemChecked( cell_axes_id );
   showcellstrainp = view->isItemChecked( cell_strain_id );
   movieframesp = view->isItemChecked(movie_frames_id);;
   showboundaryonlyp =  view->isItemChecked(only_boundary_id);
   showfluxesp = view->isItemChecked(fluxes_id);
   dynamicscellsp = options->isItemChecked(dyn_cells_id);
   showwallsp = view->isItemChecked( cell_walls_id);
   showapoplastsp = view->isItemChecked( apoplasts_id);
+  //showapoplastsp = view->isItemChecked( apoplasts_id);
   hidecellsp = view->isItemChecked( hide_cells_id);
   xmlNode *settings = MainBase::XMLSettingsTree();
   QTransform viewport(editor->transform());
   xmlAddChild(settings, XMLViewportTree(viewport));
   return settings;
+}
 /* finis */

src/canvas.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _CANVAS_H_
 #define _CANVAS_H_
 #include <q3popupmenu.h>
 #include <q3mainwindow.h>
 #include <q3intdict.h>
 #include <QGraphicsScene>
 #include <QGraphicsView>
 #include <QList>
 #include <string>
 #include <sstream>
 //Added by qt3to4:
 #include <QMouseEvent>
 #include <vector>
 #include "simitembase.h"
 #include "mainbase.h"
 #include "cellitem.h"
 #include "infobar.h"
 #include "nodeitem.h"
 #include "cell.h"
 #ifdef HAVE_QWT
 #include "data_plot.h"
 #endif
 #include <libxml/xpath.h>
 #include <libxml/xmlreader.h>
 #if defined(Q_OS_MAC)
 #define PREFIX "cmd"
 #else
 #define PREFIX "crtl"
 #endif
 class QFile;
 class QDir;
 class ModelCatalogue;
 class InfoBar;
 class FigureEditor : public QGraphicsView {
   Q_OBJECT
     friend class Main;
  public:
   FigureEditor(QGraphicsScene&, Mesh&, QWidget* parent=0, const char* name=0, Qt::WFlags f=0);
   void clear();
   void Save(const char *fname, const char *format, int sizex=640, int sizey=480);
   void FullRedraw(void);
  protected:
   void mousePressEvent(QMouseEvent*);
   void mouseMoveEvent(QMouseEvent*);
   void mouseReleaseEvent(QMouseEvent*);
   void wheelEvent(QWheelEvent *event);
   void scaleView(qreal scaleFactor);
   vector <CellItem *> getIntersectedCells(void);
   void insertNode(QPointF p);
   NodeItem *selectedNodeItem(QList<QGraphicsItem *> l) const;
  signals:
   void status(const QString&);
   void MousePressed(void);
   void MouseReleased(void);
  protected:
   Mesh &mesh;
  private:
   //NodeItem* moving;
   SimItemBase *moving;
   QPointF moving_start;
   QGraphicsLineItem *intersection_line;
   bool rotation_mode;
   bool insert_mode;
   double rot_angle;
 };
 class Main : public Q3MainWindow, public MainBase {
   Q_OBJECT
     friend class ModelCatalogue; // needs to populate menu item models
  public:
   Main(QGraphicsScene&, Mesh&, QWidget* parent=0, const char* name=0, Qt::WFlags f=0);
   ~Main();
   virtual bool ShowCentersP(void) {return view->isItemChecked(com_id);}
   virtual bool ShowMeshP(void) {return view->isItemChecked(mesh_id);}
   virtual bool ShowBorderCellsP(void) {return view->isItemChecked(border_id);}
   virtual bool PausedP(void) {return run->isItemChecked(paused_id);}
   virtual bool ShowNodeNumbersP(void) {return view->isItemChecked(node_number_id);}
   virtual bool ShowCellNumbersP(void) {return view->isItemChecked(cell_number_id);}
   virtual bool ShowCellAxesP(void) {return view->isItemChecked(cell_axes_id);}
   virtual bool ShowCellStrainP(void) {return view->isItemChecked(cell_strain_id);}
   virtual bool MovieFramesP(void) {return view->isItemChecked(movie_frames_id);}
   virtual bool ShowBoundaryOnlyP(void) {return view->isItemChecked(only_boundary_id);}
   virtual bool ShowWallsP(void) {return view->isItemChecked(cell_walls_id);}
   virtual bool ShowApoplastsP(void) { return view->isItemChecked(apoplasts_id);}
+ // virtual bool ShowApoplastsP(void) { return view->isItemChecked(apoplasts_id);}
   virtual bool ShowFluxesP(void) { return view->isItemChecked(fluxes_id); }
   virtual bool DynamicCellsP(void) { return options->isItemChecked(dyn_cells_id); }
   virtual bool RotationModeP(void) { return options->isItemChecked(rotation_mode_id); }
   virtual bool InsertModeP(void) { return options->isItemChecked(insert_mode_id); }
   virtual bool ShowToolTipsP(void) { return helpmenu->isItemChecked(tooltips_id); }
   virtual bool HideCellsP(void) { return view->isItemChecked(hide_cells_id); }
   void scale(double factor);
   virtual double getFluxArrowsize(void)
+  {
     return flux_arrow_size;
+  }
   void FitCanvasToWindow();
   void FitLeafToCanvas(void);
   public slots:
   void about();
   void gpl();
   void TimeStepWrap();
   void togglePaused();
   void setFluxArrowSize(int size);
   void RestartSim(void);
   void toggleShowCellCenters(void);
   void toggleShowNodes(void);
   void toggleShowBorderCells(void);
   void toggleShowFluxes(void);
   void toggleNodeNumbers(void);
   void toggleCellNumbers(void);
   void toggleCellAxes(void);
   void toggleCellStrain(void);
   void toggleShowWalls(void);
   void toggleShowApoplasts(void);
   void toggleDynCells(void);
   void toggleMovieFrames(void);
   void toggleLeafBoundary(void);
   void toggleHideCells(void);
   void print();
   void startSimulation(void);
   void stopSimulation(void);
   void RefreshInfoBar(void);
   void EnterRotationMode(void)
+  {
     UserMessage("Rotation mode. Click mouse to exit.");
     if (editor) {
       editor->rot_angle = 0. ;
       // Exit rotation mode if mouse is clicked
       connect(editor, SIGNAL(MousePressed()), this, SLOT(ExitRotationMode()));
       editor->setMouseTracking(true);
+    }
+  }
   void ExitRotationMode(void)
+  {
     UserMessage("Exited rotation mode.",2000);
     options->setItemChecked(rotation_mode_id, false);
     if (editor)
       disconnect(editor, SIGNAL(MousePressed()), this, SLOT(ExitRotationMode()));
     editor->setMouseTracking(false);
+  }
   virtual void UserMessage(QString message, int timeout=0);
   void Refresh(void) { Plot(); }
   void PauseIfRunning(void);
   void ContIfRunning(void);
   virtual void XMLReadSettings(xmlNode *settings);
   private slots:
   void aboutQt();
   void newView();
   void EditParameters();
   void readStateXML();
   int readStateXML(const char *filename, bool geometry = true, bool pars=true, bool simtime = true);
   void readNextStateXML();
   void readPrevStateXML();
   void readFirstStateXML();
   void readLastStateXML();
   void saveStateXML();
   void snapshot();
   void savePars();
   void readPars();
   void clear();
   void init();
   virtual void CutSAM() { MainBase::CutSAM(); Refresh();}
   void enlarge();
   void shrink();
   void zoomIn();
   void zoomOut();
   void CleanMesh();
   void CleanMeshChemicals(void);
   void CleanMeshTransporters(void);
   void RandomizeMesh();
  signals:
   void SimulationDone(void);
   void ParsChanged(void);
  protected:
   Mesh &mesh;
  private:
   NodeSet *node_set;
   FigureEditor *editor;
   Q3PopupMenu* options;
   Q3PopupMenu *view;
   Q3PopupMenu *run;
   QMenu *modelmenu;
   Q3PopupMenu *helpmenu;
   QPrinter* printer;
   const QDir *working_dir;
   QString currentFile;
   //  toggle item states
   int dbf_id; // options->Double Buffer
   int com_id; // view->Show centers
   int mesh_id; // view->Show mesh
   int node_number_id; // view->Show Node numbers
   int cell_number_id; // view->Show Cell numbers
   int border_id; // view->Show border cells
   int paused_id; // run->Simulation paused
   int cell_axes_id; // view->Show cell axes
   int cell_strain_id; // view->Show cell strain
   int only_boundary_id; // view ->Show only leaf boundary
   int cell_walls_id; // view -> Show transporters
   int apoplasts_id; // view -> Show apoplasts
+  //int apoplasts_id; // view -> Show apoplasts
   int tooltips_id; // help -> Show Cell Info
   int hide_cells_id; // view->Hide Cells
   double flux_arrow_size;
   int movie_frames_id;
   int fluxes_id;
   int dyn_cells_id;
   int rotation_mode_id;
   int insert_mode_id;
   QTimer *timer;
   QFile *gifanim;
   bool running;
   virtual xmlNode *XMLSettingsTree(void);
   static const QString caption;
   static const QString caption_with_file;
   InfoBar *infobar;
 };
 #endif
 /* finis*/

src/cell.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <QDebug>
 #include <string>
 #include "cell.h"
 #include "node.h"
 #include "mesh.h"
 #include "tiny.h"
 #include "nodeset.h"
 #include "cellitem.h"
 #include "nodeitem.h"
 #include "qcanvasarrow.h"
 #include "parameter.h"
 static const std::string _module_id("$Id$");
 extern Parameter par;
 double Cell::factor=1.;
 double Cell::offset[3]={0,0,0};
 Cell::Cell(void) : CellBase()
+{
   m=0;
+}
 Cell::Cell(double x, double y, double z) : CellBase(x,y,z)
+{
   m=0;
+}
 Cell::Cell(const Cell &src) :  CellBase(src)
+{
   m=src.m;
+}
 bool Cell::Cmp(Cell *c) const { return this->Index() < c->Index(); }
 bool Cell::Eq(Cell *c) const { return this->Index() == c->Index(); }
 Cell Cell::operator=(const Cell &src)
+{
   CellBase::operator=(src);
   m=src.m;
   return *this;
+}
 //Cell(void) : CellBase() {}
 void Cell::DivideOverAxis(Vector axis)
+{
   // Build a wall
   // ->  find the position of the wall
   // better look for intersection with a simple line intersection algorithm as below?
   // this leads to some exceptions: e.g. dividing a horizontal rectangle.
   // leaving it like this for the time being
   if (dead) return;
   Vector centroid=Centroid();
   double prev_cross_z=(axis * (centroid - *(nodes.back()) ) ).z ;
   ItList new_node_locations;
   for (list<Node *>::iterator i=nodes.begin(); i!=nodes.end(); i++) {
     // cross product to detect position of division
     Vector cross = axis * (centroid - *(*i));
     if (cross.z * prev_cross_z < 0 ) {
       new_node_locations.push_back(i);
+    }
     prev_cross_z=cross.z;
+  }
   DivideWalls(new_node_locations, centroid, centroid+axis);
+}
 double Cell::MeanArea(void)
+{
   return m->MeanArea();
+}

src/cell.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _CELL_H_
 #define _CELL_H_
 #include <list>
 #include <vector>
 #include <iostream>
 #include <QString>
 #include "vector.h"
 #include "parameter.h"
 #include "wall.h"
 #include "warning.h"
 #include "cellbase.h"
 #include "cell.h"
 #include <QGraphicsScene>
 #include <qcolor.h>
 #include <QObject>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #include <QMouseEvent>
 class Cell : public CellBase
+{
   Q_OBJECT
     friend class Mesh;
   friend class FigureEditor;
  public:
   Cell(double x, double y, double z = 0.);
   Cell(void);
   Cell(const Cell &src);
   Cell operator=(const Cell &src);
   bool Cmp(Cell*) const;
   bool Eq(Cell*) const;
   inline bool IndexEquals(int i) { return i == index; }
   static void SetMagnification(const double &magn) {
     factor=magn;
+  }
   static Vector Offset(void) {
     Vector offs;
     offs.x=offset[0];
     offs.y=offset[1];
     return offs;
+  }
   static void Translate(const double &tx,const double &ty) {
     offset[0]+=tx;
     offset[1]+=ty;
+  }
   inline static double Factor(void) {
     return factor;
+  }
   static void setOffset(double ox, double oy) {
     offset[0]=ox;
     offset[1]=oy;
+  }
   static double Magnification(void) {
     return factor;
+  }
   static double Scale(const double scale) {
     factor*=scale;
     return factor;
+  }
   void DivideOverAxis(Vector axis); // divide cell over axis
   // divide over the line (if line and cell intersect)
   bool DivideOverGivenLine(const Vector v1, const Vector v2, bool wall_fixed = false, NodeSet *node_set = 0);
   void Divide(void) { // Divide cell over short axis
     Vector long_axis;
     Length(&long_axis);
     DivideOverAxis(long_axis.Perp2D());
+  }
   //void CheckForGFDrivenDivision(void);
   inline int NNodes(void) const { return nodes.size(); }

src/cellbase.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <cmath>
 #include <string>
 #include <sstream>
 #include <vector>
 #include <algorithm>
 #include <functional>
 #ifdef QTGRAPHICS
 #include <QGraphicsScene>
 #include <qpainter.h>
 #include <qcolor.h>
 #include <qfont.h>
 #include <qwidget.h>
 //Added by qt3to4:
 #include <Q3PointArray>
 #include <fstream>
 #include "nodeitem.h"
 #include "cellitem.h"
 #include "qcanvasarrow.h"
 #endif
 #include "nodeset.h"
 #include "cellbase.h"
 #include "wall.h"
 #include "random.h"
 #include "parameter.h"
 #include "mesh.h"
 #include "sqr.h"
 #include "tiny.h"
 static const std::string _module_id("$Id$");
 extern Parameter par;
 const char* CellBase::boundary_type_names[4] = {"None", "NoFlux", "SourceSink", "SAM"};
 #ifndef VLEAFPLUGIN
 CellsStaticDatamembers *CellBase::static_data_members = new CellsStaticDatamembers();
 #else
 CellsStaticDatamembers *CellBase::static_data_members = 0;
 #endif
 CellBase::CellBase(QObject *parent) :
   QObject(parent),
   Vector()
+{
   chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     chem[i]=0.;
+  }
   new_chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     new_chem[i]=0.;
+  }
   boundary=None;
   index=(NCells()++);
   area=0.;
   target_area=1;
   target_length=0; //par.target_length;
   lambda_celllength = 0; //par.lambda_celllength;
   intgrl_xx=0.; intgrl_xy=0.; intgrl_yy=0.;
   intgrl_x=0.; intgrl_y=0.;
   source = false;
   source_conc = 0.;
   source_chem = 0;
   at_boundary=false;
   fixed = false;
   pin_fixed = false;
   stiffness = 0;
   marked = false;
   dead = false;
   div_counter=0;
   cell_type = 0;
   flag_for_divide = false;
   division_axis = 0;
+}
 CellBase::CellBase(double x,double y,double z) : QObject(), Vector(x,y,z)
+{
 #ifndef VLEAFPLUGIN
   if (static_data_members == 0) {
     static_data_members = new CellsStaticDatamembers();
+  }
 #endif
   chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     chem[i]=0.;
+  }
   new_chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     new_chem[i]=0.;
+  }
   boundary=None;
   area=0.;
   target_area=1;
   target_length=0; //par.target_length;
   lambda_celllength=0; // par.lambda_celllength;
   index=(NCells()++);
   intgrl_xx=0.; intgrl_xy=0.; intgrl_yy=0.;
   intgrl_x=0.; intgrl_y=0.;
   source = false;
   fixed = false;
   at_boundary=false;
   pin_fixed = false;
   stiffness = 0;
   marked=false;
   dead  = false;
   div_counter = 0;
   cell_type = 0;
   flag_for_divide = false;
   division_axis = 0;
+}
-CellBase::CellBase(const CellBase &src) :  Vector(src), QObject()
+CellBase::CellBase(const CellBase &src) :  QObject(), Vector(src)
+{
   chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     chem[i]=src.chem[i];
+  }
   new_chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     new_chem[i]=src.new_chem[i];
+  }
   boundary=src.boundary;
   area=src.area;
   target_length=src.target_length;
   lambda_celllength=src.lambda_celllength;
   intgrl_xx=src.intgrl_xx; intgrl_xy=src.intgrl_xy; intgrl_yy=src.intgrl_yy;
   intgrl_x=src.intgrl_x; intgrl_y=src.intgrl_y;
   target_area=src.target_area;
   index=src.index;
   nodes=src.nodes;
   neighbors=src.neighbors;
   walls=src.walls;
   source = src.source;
   fixed = src.fixed;
   source_conc = src.source_conc;
   source_chem = src.source_chem;
   cellvec = src.cellvec;
   at_boundary=src.at_boundary;
   pin_fixed = src.pin_fixed;
   stiffness = src.stiffness;
   marked = src.marked;
   dead = src.dead;
   cell_type = src.cell_type;
   div_counter = src.div_counter;
   flag_for_divide = src.flag_for_divide;
   division_axis = src.division_axis;
+}
 CellBase CellBase::operator=(const CellBase &src)
+{
   Vector::operator=(src);
   for (int i=0;i<NChem();i++) {
     chem[i]=src.chem[i];
+  }
   for (int i=0;i<NChem();i++) {
     new_chem[i]=src.chem[i];
+  }
   boundary=src.boundary;
   area=src.area;
   intgrl_xx=src.intgrl_xx; intgrl_xy=src.intgrl_xy; intgrl_yy=src.intgrl_yy;
   intgrl_x=src.intgrl_x; intgrl_y=src.intgrl_y;
   target_area=src.target_area;
   target_length=src.target_length;
   lambda_celllength=src.lambda_celllength;
   index=src.index;
   nodes=src.nodes;
   neighbors=src.neighbors;
   walls=src.walls;
   source = src.source;
   fixed = src.fixed;
   source_conc = src.source_conc;
   source_chem = src.source_chem;
   cellvec = src.cellvec;
   at_boundary=src.at_boundary;
   pin_fixed = src.pin_fixed;
   stiffness = src.stiffness;
   marked = src.marked;
   dead = src.dead;
   cell_type = src.cell_type;
   div_counter = src.div_counter;
   flag_for_divide = src.flag_for_divide;
   division_axis = src.division_axis;
   return *this;
+}
 void CellBase::SetChemical(int c, double conc)
+{
   if (c>=NChem()) {
     stringstream error;
     error << "SetChemical: value c = " << c << " is out of range\n";
     throw error.str().c_str();
+  }
   chem[c]=conc;
+}
 void CellBase::SetTransporters(int ch, double conc)
+{
   if (ch>=NChem()) {
     stringstream error;
     error << "SetChemical: value ch = " << ch << " is out of range\n";
     throw error.str().c_str();

src/cellbase.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 // CellBase derives from Vector, where Vector is simply used as a Vertex
 #ifndef _CELLBASE_H_
 #define _CELLBASE_H_
 #include <list>
 #include <vector>
 #include <iostream>
 #include <QString>
 #include <QDebug>
 #include "vector.h"
 #include "parameter.h"
 #include "wall.h"
 #include "warning.h"
 #include "assert.h"
 extern Parameter par;
 using namespace std;
 class Mesh;
 class Node;
 class CellBase;
 class NodeSet;
 struct ParentInfo {
   Vector polarization;
   double PINmembrane;
   double PINendosome;
 };
 // We need a little trick here, to make sure the plugin and the main application will see the same static datamembers
 // otherwise each have their own instantation.
-// My solution is as follow. I collect all original statics in a class. The main application instantiates it and
+// My solution is as follows. I collect all original statics in a class. The main application instantiates it and
 // has a static pointer to it. After loading the plugin I set a static pointer to the same class
 class CellsStaticDatamembers {
  public:
   CellsStaticDatamembers(void) {
     ncells = 0;
     nchem = 0;
     base_area = 0.;
+  }
   ~CellsStaticDatamembers() {
 #ifdef QDEBUG
     qDebug() << "Oops! Desctructor of CellsStaticDatamembers called" << endl;
 #endif
+  }
   int ncells;
   int nchem;
   double base_area;
 };
 class CellBase :  public QObject, public Vector
+{
   Q_OBJECT
   friend class Mesh;
   friend class CellInfo;
   friend class Node;
   friend class WallBase;
   friend class SimPluginInterface;
  public:
   CellBase(QObject *parent=0);
   CellBase(double x,double y,double z=0); // constructor
   virtual ~CellBase() {
     delete[] chem;
     delete[] new_chem;
     if (division_axis) delete division_axis;
     //cerr << "CellBase " << index << " is dying. " << endl;
+  }
   CellBase(const CellBase &src); // copy constructor
   virtual bool BoundaryPolP(void) const { return false; }
   CellBase operator=(const CellBase &src); // assignment operator
   CellBase operator=(const Vector &src);
   void SetChemical(int chem, double conc);
   inline void SetNewChem(int chem, double conc)
+  {
     new_chem[chem] = conc;
+  }
   void SetSource(int chem, double conc)
+  {
     source=true;
     source_chem = chem;
     source_conc = conc;
+  }
   // set chem 1 to conc in all membranes of this cell
   void SetTransporters(int chem, double conc);
   void UnfixNodes(void);
   void FixNodes(void);
   void UnsetSource(void) {
     source = false;
+  }
   inline bool Source(void) { return source; }
   enum boundary_type {None, Noflux, SourceSink, SAM};
   static const char * boundary_type_names[4];
   inline const char *BoundaryStr(void) { return boundary_type_names[boundary]; }
   ostream &print(ostream &os) const;
   inline double Chemical(int c) const { // returns the value of chemical c
 #ifdef _undefined_
     qDebug() << endl << "Entering cellbase::chemical(" << c << "), and nchem is: " << NChem() << "." << endl;
 #endif
     int nchem = NChem();
 #ifdef _undefined_
     if ((c<0) || (c>=nchem))
       MyWarning::warning("CellBase::Chemical says: index c is: %d, but nchem is: %d. Merely return zero", c, nchem);
 #endif
     return ((c<0) || (c>=nchem)) ? 0 : chem[c];
+  }
   //void print_nblist(void) const;
   boundary_type SetBoundary(boundary_type bound)

src/cellitem.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include<QGraphicsScene>
 #include "cellitem.h"
 static const std::string _module_id("$Id$");
 CellItem::CellItem( Cell *c, QGraphicsScene *canvas )
   : QGraphicsPolygonItem( 0, canvas ), SimItemBase( c, canvas){
+}
 void CellItem::userMove(double dx, double dy)
+{
   QGraphicsPolygonItem::moveBy( dx, dy );
   // also move the cell itself
   class_cast<Cell *>(obj)->x += (dx/Cell::Magnification());
   class_cast<Cell *>(obj)->y += (dy/Cell::Magnification());
   class_cast<Cell*>(obj)->Move( (dx/Cell::Magnification()), (dy/Cell::Magnification()) );
+}
 QPainterPath CellItem::shape() const { return QGraphicsPolygonItem::shape(); }
 QRectF CellItem::boundingRect() const { return QGraphicsPolygonItem::boundingRect(); }
 /* finis */

src/cellitem.h

➞

Show inline comments

 /*
  *  VirtualLeaf
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _CELLITEM_H_
 #define _CELLITEM_H_
 #include <QGraphicsScene>
 #include <QGraphicsPolygonItem>
 #include <QPainter>
 #include "simitembase.h"
 #include "cell.h"
 class CellItem : public QGraphicsPolygonItem, public SimItemBase
+{
  public:
   CellItem( Cell *n, QGraphicsScene *canvas );
   virtual ~CellItem() {}
   Cell &getCell(void) const { return *class_cast<Cell*>(obj); }
   virtual void userMove(double dx, double dy);
   QPainterPath shape() const;
   QRectF boundingRect() const;
  private:
 };
 #endif
 /* finis */

src/forwardeuler.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <cmath>
 #include <iostream>
 #include "forwardeuler.h"
 #include "warning.h"
 #include "maxmin.h"
 #include <string>
 using namespace std;
 static const string _module_id("$Id$");
 // The value Errcon equals (5/Safety) raised to the power (1/PGrow), see use below.
 const double ForwardEuler::Safety  = 0.9;
 const double ForwardEuler::PGrow = -0.2;
 const double ForwardEuler::Pshrnk = -0.25;
 const double ForwardEuler::Errcon = 1.89e-4;
 const double ForwardEuler::Maxstp = 10000000;
 const double ForwardEuler::Tiny = 1.0e-30;
 /* User storage for intermediate results. Preset kmax and dxsav in the calling program. If kmax =
 results are stored at approximate intervals dxsav in the arrays xp[1..kount], yp[1..nvar]
    [1..kount], where kount is output by odeint. Defining declarations for these variables, with
    memoryallo cations xp[1..kmax] and yp[1..nvar][1..kmax] for the arrays, should be in
    the calling program.*/
 void ForwardEuler::odeint(double *ystart, int nvar, double x1, double x2, double eps, double h1, double hmin, int *nok, int *nbad)
 /* Runge-Kutta driver with adaptive stepsize control. Integrate starting values ystart[1..nvar]
    from x1 to x2 with accuracy eps, storing intermediate results in global variables. h1 should
    be set as a guessed first stepsize, hmin as the minimum allowed stepsize (can be zero). On
    output nok and nbad are the number of good and bad (but retried and fixed) steps taken, and
    ystart is replaced byv alues at the end of the integration interval. derivs is the user-supplied
    routine for calculating the right-hand side derivative, while rkqs is the name of the stepper
    routine to be used. */
+{
   static bool warning_issued = false;
   if (!warning_issued) {
     cerr << "Using inaccurate method ForwardEuler\n";
     warning_issued=true;
     //MyWarning::warning("Using inaccurate method ForwardEuler");
+  }
   // N.B. Not for serious use and not fully usage compatible with RungeKutta
   // simply for testing API of integrator.
   double *y,*dydx;
   y=new double[nvar];
   dydx=new double[nvar];
   double x=x1;
   for (int i=0;i<nvar;i++) y[i]=ystart[i];
   //if (kmax > 0) xsav=x-dxsav*2.0; //Assures storage of first step.
   dydx=new double[nvar];
   for (int nstp=0;nstp<Maxstp;nstp++) {
     derivs(x,y,dydx);
     if (kmax > 0 && kount < kmax-1) {
       xp[kount]=x; //Store intermediate results.
       for (int i=0;i<nvar;i++) yp[i][kount]=y[i];
       kount++;
       //xsav=x;
+    }
     for (int i=0;i<nvar;i++) {
       y[i]=y[i] + h1 * dydx[i];
+    }
     x = x + h1;
     if ((x-x2)*(x2-x1) >= 0.0) { //Are we done?
       goto done;
+    }
+  }
  done:
   for (int i=0;i<nvar;i++) ystart[i]=y[i];
   if (kmax) {
     xp[kount]=x; //Save final step.
     for (int i=0;i<nvar;i++) yp[i][kount]=y[i];

src/forwardeuler.h

➞

Show inline comments

 /*
  *  VirtualLeaf
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _FORWARDEULER_H_
 #define _FORWARDEULER_H_
 class ForwardEuler  {
  public:
   ForwardEuler(void) {
     kmax=kount=0;
     dxsav=0.;
     xp=0;
     yp=0;
+  }
   virtual ~ForwardEuler() {}
   void odeint(double ystart[], int nvar, double x1, double x2, double eps, double h1,
 	      double hmin, int *nok, int *nbad);
   // implement this function in a derived class
  protected:
   virtual void derivs(double x, double *y, double *dxdy) = 0;
   int kmax,kount;
   double *xp,**yp,dxsav;
  private:
   static const double Safety;
   static const double PGrow;
   static const double Pshrnk;
   static const double Errcon;
   static const double Maxstp;
   static const double Tiny;
 };
 #endif
 /* finis */

src/infobar.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _INFOBAR_H_
 #define _INFOBAR_H_
 #include <q3mainwindow.h>
 #include <QLabel>
 #include <QBoxLayout>
 class InfoBar : public Q3DockWindow {
   Q_OBJECT
     public:
   InfoBar(void) : Q3DockWindow() {
     virtleaf = new QLabel();
     SetText("undefined");
     setHorizontalStretchable(true);
     boxLayout()->addStretch();
     boxLayout()->addWidget(virtleaf);//, Qt::AlignHCenter);
     boxLayout()->addStretch();
+  }
   void SetText(QString text) {
-    virtleaf->setText(QString("<h1>The Virtual Leaf</h1>\n<center><b>Model:</b> <i>%1</i></center>").arg(text));
+    virtleaf->setText(QString("<h1>VirtualLeaf</h1>\n<center><b>Model:</b> <i>%1</i></center>").arg(text));
+  }
  private:
   QLabel *virtleaf;
 };
 #endif
 /* finis */

src/libplugin.pro

➞

Show inline comments

+#
 #  $Id$
+#
 #  This file is part of the Virtual Leaf.
+#
 #  The Virtual Leaf is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation, either version 3 of the License, or
 #  (at your option) any later version.
+#
 #  The Virtual Leaf is distributed in the hope that it will be useful,
 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #  GNU General Public License for more details.
+#
 #  You should have received a copy of the GNU General Public License
 #  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+#
 #  Copyright 2010 Roeland Merks.
+#
 CONFIG += release
 CONFIG -= debug
 CONFIG += staticlib
 QMAKE_CXXFLAGS += -fexceptions
 win32:QMAKE_CXXFLAGS -= O2
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QMAKE_CXXFLAGS_DEBUG -= -finstrument-functions
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = ../lib
 PARTMPL = VirtualLeafpar.tmpl
 QT += qt3support
 TARGET = vleaf
 TEMPLATE = lib
 HEADERS = \
  cellbase.h \
  matrix.h \
  output.h \
  parameter.h \
  parse.h \
  random.h \
  simplugin.h \
  UniqueMessage.h \
  vector.h \
  wallbase.h \
  warning.h
 SOURCES = \
  cellbase.cpp \
  matrix.cpp \
  output.cpp \
  parameter.cpp \
  parse.cpp \
  random.cpp \
  simplugin.cpp \
  UniqueMessage.cpp \
  vector.cpp \
  wallbase.cpp \
  warning.cpp
 unix {
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
  LIBS += -lxml2 -lz -lm
+}
 win32 {
  LIBXML2DIR = ..\lib\libxml2
  LIBICONVDIR = ..\lib\libiconv
  LIBZDIR = ..\lib\libz
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  LIBXML2DIR = C:
  LIBICONVDIR = C:
  LIBZDIR = C:
 # QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
+#

src/mainbase.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <libxml/xpath.h>
 #include <libxml/xmlreader.h>
 #include "mainbase.h"
 #include "xmlwrite.h"
 #include <sstream>
 #include <string>
 #include <QLocale>
 static const std::string _module_id("$Id$");
 xmlNode *MainBase::XMLViewportTree(QTransform &transform) const {
   QLocale standardlocale(QLocale::C);
   xmlNode *xmlviewport = xmlNewNode(NULL, BAD_CAST "viewport");
+  {
     xmlNewProp(xmlviewport, BAD_CAST "m11", BAD_CAST standardlocale.toString(transform.m11()).toStdString().c_str() );
     xmlNewProp(xmlviewport, BAD_CAST "m12", BAD_CAST standardlocale.toString(transform.m12()).toStdString().c_str() );
     xmlNewProp(xmlviewport, BAD_CAST "m21", BAD_CAST standardlocale.toString(transform.m21()).toStdString().c_str() );
     xmlNewProp(xmlviewport, BAD_CAST "m22", BAD_CAST standardlocale.toString(transform.m22()).toStdString().c_str() );
     xmlNewProp(xmlviewport, BAD_CAST "dx", BAD_CAST standardlocale.toString(transform.dx()).toStdString().c_str() );
     xmlNewProp(xmlviewport, BAD_CAST "dy", BAD_CAST standardlocale.toString(transform.dy()).toStdString().c_str() );
+ }
   return xmlviewport;
+}
 xmlNode *MainBase::XMLSettingsTree(void) const {
   xmlNode *xmlsettings = xmlNewNode(NULL, BAD_CAST "settings");
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_cell_centers");
     ostringstream text;
     text << bool_name(showcentersp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_nodes");
     ostringstream text;
     text << bool_name(showmeshp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_node_numbers");
     ostringstream text;
     text << bool_name(shownodenumbersp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_cell_numbers");
     ostringstream text;
     text << bool_name(showcellnumbersp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_border_cells");
     ostringstream text;
     text << bool_name(showbordercellp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_cell_axes");
     ostringstream text;
     text << bool_name(showcellsaxesp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_cell_strain");
     ostringstream text;
     text << bool_name(showcellstrainp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_fluxes");
     ostringstream text;
     text << bool_name(showfluxesp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_walls");
     ostringstream text;
     text << bool_name(showwallsp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
+ /* {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_apoplasts");
     ostringstream text;
     text << bool_name(showapoplastsp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  }*/
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "save_movie_frames");
     ostringstream text;
     text << bool_name(movieframesp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "show_only_leaf_boundary");
     ostringstream text;
     text << bool_name(showboundaryonlyp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "cell_growth");
     ostringstream text;
     text << bool_name(dynamicscellsp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
+  {
     xmlNode *xmloption = xmlNewChild(xmlsettings, NULL, BAD_CAST "setting", NULL);
     xmlNewProp(xmloption, BAD_CAST "name", BAD_CAST "hide_cells");
     ostringstream text;
     text << bool_name(hidecellsp);
     xmlNewProp(xmloption, BAD_CAST "val", BAD_CAST text.str().c_str());
+  }
   return xmlsettings;
+}
 void MainBase::XMLReadViewport(xmlNode *settings) {
   if (settings == 0) {
     return;
+  }
   qreal m11=25,m12=0,m21=0,m22=25,dx=0,dy=0;
   QLocale standardlocale(QLocale::C);
   xmlNode *cur = settings->xmlChildrenNode;
   while (cur!=NULL) {
     if (!xmlStrcmp(cur->name,(const xmlChar *)"viewport")) {
       bool ok;
+      {
 	xmlChar *v_str = xmlGetProp(cur, BAD_CAST "m11");
 	if (v_str==0) {
 	  MyWarning::unique_warning("Error reading viewport in mainbase.cpp");
+	}
 	if (v_str != NULL) {
 	  m11=standardlocale.toDouble((char *)v_str, &ok);
 	  if (!ok) MyWarning::error("Could Not Convert \"%S\" To Double In XMLRead.",(char *)v_str);
 	  xmlFree(v_str);
+	}
+      }
+      {
 	xmlChar *v_str = xmlGetProp(cur, BAD_CAST "m12");
 	if (v_str==0) {
 	  MyWarning::unique_warning("Error reading viewport in mainbase.cpp");
+	}
 	if (v_str != NULL) {
 	  m12=standardlocale.toDouble((char *)v_str, &ok);
 	  if (!ok) MyWarning::error("Could Not Convert \"%S\" To Double In XMLRead.",(char *)v_str);
 	  xmlFree(v_str);
+	}
+      }
+      {
 	xmlChar *v_str = xmlGetProp(cur, BAD_CAST "m21");
 	if (v_str==0) {
 	  MyWarning::unique_warning("Error reading viewport in mainbase.cpp");
+	}
 	if (v_str != NULL) {
 	  m21=standardlocale.toDouble((char *)v_str, &ok);
 	  if (!ok) MyWarning::error("Could Not Convert \"%S\" To Double In XMLRead.",(char *)v_str);
 	  xmlFree(v_str);
+	}
+      }
+      {
 	xmlChar *v_str = xmlGetProp(cur, BAD_CAST "m22");
 	if (v_str==0) {
 	  MyWarning::unique_warning("Error reading viewport in mainbase.cpp");
+	}
 	if (v_str != NULL) {
 	  m22=standardlocale.toDouble((char *)v_str, &ok);
 	  if (!ok) MyWarning::error("Could Not Convert \"%S\" To Double In XMLRead.",(char *)v_str);
 	  xmlFree(v_str);
+	}
+      }
+      {
 	xmlChar *v_str = xmlGetProp(cur, BAD_CAST "dx");
 	if (v_str==0) {
 	  MyWarning::unique_warning("Error reading viewport in mainbase.cpp");
+	}
 	if (v_str != NULL) {
 	  dx=standardlocale.toDouble((char *)v_str, &ok);
 	  if (!ok) MyWarning::error("Could Not Convert \"%S\" To Double In XMLRead.",(char *)v_str);
 	  xmlFree(v_str);
+	}
+      }
+      {
 	xmlChar *v_str = xmlGetProp(cur, BAD_CAST "dy");
 	if (v_str==0) {
 	  MyWarning::unique_warning("Error reading viewport in mainbase.cpp");
+	}
 	if (v_str != NULL) {
 	  dy=standardlocale.toDouble((char *)v_str, &ok);
 	  if (!ok) MyWarning::error("Could Not Convert \"%S\" To Double In XMLRead.",(char *)v_str);
 	  xmlFree(v_str);
+	}
+      }
+    }
     cur=cur->next;
+  }
   viewport = QTransform(m11,m12,m21,m22,dx,dy);
+}
 void MainBase::XMLReadSettings(xmlNode *settings)
+{
   // Many files have no settings section, so don't complain about it.
   // Defaults will be used instead.
   if (settings == 0) {
     return;
+  }
   XMLReadViewport(settings);
   xmlNode *cur = settings->xmlChildrenNode;
   while (cur!=NULL) {
     if ((!xmlStrcmp(cur->name, (const xmlChar *)"setting"))){
       xmlChar *name = xmlGetProp(cur, BAD_CAST "name");
       xmlChar *val = xmlGetProp(cur, BAD_CAST "val");
       if (!xmlStrcmp(name, (const xmlChar *)"show_cell_centers")) {
 	showcentersp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_nodes")) {
 	showmeshp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_node_numbers")) {
 	shownodenumbersp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_cell_numbers")) {
 	showcellnumbersp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_border_cells")) {
 	showbordercellp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_cell_axes")) {
 	showcellsaxesp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_cell_strain")) {
 	showcellstrainp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_fluxes")) {
 	showfluxesp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_walls")) {
 	showwallsp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_apoplasts")) {
+     /* if (!xmlStrcmp(name, (const xmlChar *)"show_apoplasts")) {
 	showapoplastsp = strtobool( (const char *)val );
+      }
+      }*/
       if (!xmlStrcmp(name, (const xmlChar *)"save_movie_frames")) {
 	movieframesp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"show_only_leaf_boundary")) {
 	showboundaryonlyp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name, (const xmlChar *)"cell_growth")) {
 	dynamicscellsp = strtobool( (const char *)val );
+      }
       if (!xmlStrcmp(name,(const xmlChar *)"hide_cells")) {
 	hidecellsp = strtobool( (const char *)val );
+      }
       xmlFree(name);
       xmlFree(val);
+    }
     cur=cur->next;
+  }
+}
 void MainBase::Save(const char *fname, const char *format, int sizex, int sizey)
+{
   Vector ll,ur;
   mesh.BoundingBox(ll, ur);
   if (QString(fname).isEmpty()) {
     MyWarning::warning("No output filename given. Saving nothing.\n");
     return;
+  }
   ll*=Cell::Magnification(); ur*=Cell::Magnification();
   // give the leaf some space
   Vector border = ((ur-ll)/5.);
   if (!QString(format).contains("pdf", Qt::CaseInsensitive)) {
     QImage *image = new QImage(QSize(sizex, sizey), QImage::Format_RGB32);
     image->fill(QColor(Qt::white).rgb());
     QPainter *painter=new QPainter(image);
     canvas.render(painter);
     if (!image->save(QString(fname))) {
       MyWarning::warning("Image not saved successfully. Is the disk full or the extension not recognized?");
     };
     delete painter;
     delete image;
   } else {
     QPrinter pdf(QPrinter::HighResolution);
     pdf.setOutputFileName(fname);
     pdf.setOutputFormat(QPrinter::PdfFormat);
     QPainter painter(&pdf);
     canvas.render(&painter, QRectF(), QRectF(-5000,-5000, 10000, 10000));
     cerr << "Rendering to printer\n";
+  }
+}
 void MainBase::CutSAM()
+{
   mesh.CutAwaySAM();
+}
 /* finis */

src/mainbase.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _MAINBASE_H_
 #define _MAINBASE_H_
 #include <QGraphicsScene>
 #include <qpixmap.h>
 #include <q3picture.h>
 #include <qpainter.h>
 #include <qwidget.h>
 #include <iostream>
 #include <QGraphicsItem>
 #include <QPrinter>
 #include "mesh.h"
 #include "warning.h"
 using namespace std;
 /*! Implement these functions in your main application */
 class MainBase  {
  public:
  MainBase(QGraphicsScene &c, Mesh &m) : mesh(m), canvas(c) {
     // Standard options for batch version
     showcentersp =  false;
     showmeshp =  false;
     showbordercellp =  false;
     shownodenumbersp =  false;
     showcellnumbersp =  false;
     showcellsaxesp = false;
     showcellstrainp =  false;
     movieframesp = true;
     showboundaryonlyp =  false;
     showwallsp =  false;
     showfluxesp = false;
     dynamicscellsp = true;
     showtooltipsp = false;
     hidecellsp = false;
+  }
   virtual ~MainBase() {};
   virtual double TimeStep();
   virtual void Init(char *leaffile=0);
   virtual bool ShowCentersP(void) {return showcentersp;}
   virtual bool ShowMeshP(void) {return showmeshp; }
   virtual bool ShowBorderCellsP(void) {return showbordercellp; }
   virtual bool PausedP(void) {return false; }
   virtual bool ShowNodeNumbersP(void) {return shownodenumbersp; }
   virtual bool ShowCellNumbersP(void) {return showcellnumbersp;}
   virtual bool ShowCellAxesP(void) {return showcellsaxesp;}
   virtual bool ShowCellStrainP(void) {return showcellstrainp;}
   virtual bool MovieFramesP(void) {return movieframesp;}
   virtual bool ShowBoundaryOnlyP(void) {return showboundaryonlyp;}
   virtual bool ShowToolTipsP(void) {return showtooltipsp;}
   virtual bool ShowWallsP(void) {return showwallsp;}
   virtual bool ShowApoplastsP(void) { return showapoplastsp;}
+ // virtual bool ShowApoplastsP(void) { return showapoplastsp;}
   virtual bool ShowFluxesP(void) { return showfluxesp; }
   virtual bool DynamicCellsP(void) { return dynamicscellsp; }
   virtual void FitCanvasToWindow() {};
   virtual void FitLeafToCanvas() {};
   virtual bool HideCellsP(void) { return hidecellsp; }
   virtual void clear(void) {
     QList<QGraphicsItem *> list = canvas.items();
     QList<QGraphicsItem *>::Iterator it = list.begin();
     for (; it != list.end(); ++it) {
       if ( *it )
 	delete *it;
+    }
   };
   virtual void XMLReadSettings(xmlNode *settings);
   virtual void XMLReadViewport(xmlNode *viewport);
   virtual double getFluxArrowsize(void) { return 10.;}
   void Save(const char *fname, const char *format, int sizex=640, int sizey=480);
   void CutSAM(void);
   void Plot(int resize_stride=10);
   virtual void UserMessage(QString message, int timeout = 0) {
     cerr << message.toAscii().constData() << endl;
+  }
   Mesh &mesh;
   QTransform viewport;
  protected:
   QGraphicsScene &canvas;
   virtual xmlNode *XMLSettingsTree(void) const;
   virtual xmlNode *XMLViewportTree(QTransform &transform) const;
  protected:
   bool showcentersp;
   bool showmeshp;
   bool showbordercellp;
   bool shownodenumbersp;
   bool showcellnumbersp;
   bool showcellsaxesp;
   bool showcellstrainp;
   bool movieframesp;
   bool showboundaryonlyp;
   bool showwallsp;
   bool showapoplastsp;
+//  bool showapoplastsp;
   bool showfluxesp;
   bool dynamicscellsp;
   bool showtooltipsp;
   bool hidecellsp;
 };
 //#include <qapplication.h>
 #define TIMESTEP double MainBase::TimeStep(void)
 #define INIT void MainBase::Init(char *leaffile)
 #endif
 /* finis */

src/matrix.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <ostream>
 #include <cmath>
 #include "vector.h"
 #include "matrix.h"
 #include "tiny.h"
 static const std::string _module_id("$Id$");
 Matrix::Matrix(const Vector &c1, const Vector &c2, const Vector &c3) {
   Alloc();
   mat[0][0]=c1.x; mat[0][1]=c2.x; mat[0][2]=c3.x;
   mat[1][0]=c1.y; mat[1][1]=c2.y; mat[1][2]=c3.y;
   mat[2][0]=c1.z; mat[2][1]=c2.z; mat[2][2]=c3.z;
+}
 void Matrix::Alloc(void)
+{
   // constructor
   mat = new double*[3];
   mat[0] = new double[9];
   for (int i=1;i<3;i++)
     mat[i]=mat[i-1]+3;
+}
 Matrix::~Matrix()
+{
   // destructor
   delete[] mat[0];
   delete[] mat;
+}
 Matrix::Matrix(void)
+{
   // constructor
   Alloc();
   // clear matrix
   for (int i=0;i<9;i++) {
     mat[0][i]=0.;
+  }
+}
 Matrix::Matrix(const Matrix &source)
+{
   // copy constructor
   Alloc();
   for (int i=0;i<9;i++) {
     mat[0][i]=source.mat[0][i];
+  }
+}
 void Matrix::operator=(const Matrix &source)
+{
   // assignment
   // don't assign to self
   if (this==&source) return;
   // copy
   for (int i=0;i<9;i++)
     mat[0][i]=source.mat[0][i];
+}
 void Matrix::print(ostream *os)
+{
   *os << "{ { " << mat[0][0] << "," << mat[0][1] << "," << mat[0][2]
       << "},{" << mat[1][0] << "," << mat[1][1] << "," << mat[1][2]
       << "},{" << mat[2][0] << "," << mat[2][1] << "," << mat[2][2] << "} }";
+}
 ostream &operator<<(ostream &os, Matrix &v) {
   v.print(&os);
   return os;
+}
 Vector Matrix::operator*(const Vector &v) const
+{
   // matrix * vector

src/matrix.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _MATRIX_H_
 #define _MATRIX_H_
 // three by three matrix (mostly for changes of basis of the vector object)
 class Vector;
 class Matrix {
  public:
   Matrix(const Vector &v1,const Vector &v2, const Vector &v3); // constructor
   Matrix(void);
   ~Matrix(); // destructor
   void print(ostream *os);
   Matrix(const Matrix &source); // copy constructor
   void operator=(const Matrix &source); // assignment operator
   Vector operator*(const Vector &v) const; // matrix * vector
   bool operator==(Matrix &v) const; // comparison
   double Det(void) const; // gives the "determinant" (| m |) of m
   Matrix Inverse(void) const; // gives the inverse of m
   void Rot2D(double theta); // make a matrix doing a 2D rotation over theta
   // data members
   double **mat;
  private:
   void Alloc(void);
 };
 ostream &operator<<(ostream &os, Matrix &v);
 #endif
 /* finis */

src/mesh.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <algorithm>
 #include <vector>
 #include <sstream>
 #include <cstdlib>
 //#include <cerrno>
 #include <cstring>
 #include <numeric>
 #include <functional>
 #include <fstream>
 #include <QPair>
 #include "mesh.h"
 #include "tiny.h"
 #include "parameter.h"
 #include "random.h"
 #include "pi.h"
 #include "parse.h"
 #include "matrix.h"
 #include "sqr.h"
 #include "nodeset.h"
 #include "nodeitem.h"
 #include "simplugin.h"
 #include <QDebug>
 #include <set>
 #include <iostream>
 #include <iterator>
 static const std::string _module_id("$Id$");
 extern Parameter par;
 void Mesh::AddNodeToCellAtIndex(Cell *c, Node *n, Node *nb1, Node *nb2, list<Node *>::iterator ins_pos) {
   c->nodes.insert(ins_pos, n);
   n->owners.push_back( Neighbor(c, nb1, nb2 ) );
+}
 void Mesh::AddNodeToCell(Cell *c, Node *n, Node *nb1, Node *nb2) {
   c->nodes.push_back( n );
   n->owners.push_back( Neighbor(c, nb1, nb2 ) );
+}
 void Mesh::PerturbChem(int chemnum, double range) {
   for (vector<Cell *>::iterator i=cells.begin(); i!=cells.end(); i++) {
     (*i)->chem[chemnum] += range*(RANDOM()-0.5);
     if ((*i)->chem[chemnum]<0.) (*i)->chem[chemnum]=0.;
+  }
+}
 void Mesh::CellFiles(const Vector ll, const Vector ur) {
   Cell *cell = RectangularCell(ll,ur,0.001);
   for (int c=0;c<Cell::NChem();c++) {
     cell->SetChemical(c,par.initval[c]);
+  }
   cell->SetTargetArea(cell->CalcArea());
   Vector axis(1,0,0);
   // divide rectangle a number of times
   for (int i=0;i<6;i++) {
     IncreaseCellCapacityIfNecessary();
     vector <Cell *> current_cells = cells;
     for (vector<Cell *>::iterator j=current_cells.begin(); j!=current_cells.end();j++) {
       (*j)->DivideOverAxis(axis);
+    }
     axis=axis.Perp2D();
+  }
   IncreaseCellCapacityIfNecessary();
   axis=axis.Perp2D();
   vector <Cell *> current_cells = cells;
   for (vector<Cell *>::iterator j=current_cells.begin(); j!=current_cells.end();j++) {
     (*j)->DivideOverAxis(axis);
+  }
@@ @@ -387,294 +387,281 @@ void Mesh::BoundingBox(Vector &LowerLeft @@
   LowerLeft = **nodes.begin();
   UpperRight = **nodes.begin();
   for (vector<Node *>::iterator c=nodes.begin(); c!=nodes.end(); c++) {
     if ((*c)->x < LowerLeft.x)
       LowerLeft.x = (*c)->x;
     if ((*c)->y < LowerLeft.y)
       LowerLeft.y = (*c)->y;
     if ((*c)->z < LowerLeft.z)
       LowerLeft.z = (*c)->z;
     if ((*c)->x > UpperRight.x)
       UpperRight.x = (*c)->x;
     if ((*c)->y > UpperRight.y)
       UpperRight.y = (*c)->y;
     if ((*c)->z > UpperRight.z)
       UpperRight.z = (*c)->z;
+  }
+}
 double Mesh::Area(void) {
   double area=0;
   vector<Cell *>::iterator i=cells.begin();
   while (i != cells.end()) {
     area += (*(i++))->Area();
+  }
   return area;
+}
 void Mesh::SetBaseArea(void) {
   // Set base area to mean area.
   // This method is typically called during initiation, after
   // defining the first cell
   Cell::BaseArea() = Area()/cells.size();
+}
 // for optimization, we moved Displace to Mesh
 class DeltaIntgrl {
 public:
   double area;
   double ix, iy;
   double ixx,ixy,iyy;
   DeltaIntgrl(double sarea,double six,double siy,double sixx,double sixy,double siyy) {
     area=sarea;
     ix=six;
     iy=siy;
     ixx=sixx;
     ixy=sixy;
     iyy=siyy;
+  }
 };
 void Mesh::Clear(void) {
   // clear nodes
   for (vector<Node *>::iterator i=nodes.begin(); i!=nodes.end(); i++) {
     delete *i;
+  }
   nodes.clear();
   Node::nnodes=0;
   node_insertion_queue.clear();
   // Clear NodeSets
   for (vector<NodeSet *>::iterator i=node_sets.begin(); i!=node_sets.end(); i++) {
     delete *i;
+  }
   node_sets.clear();
   time = 0;
   // clear cells
   for (vector<Cell *>::iterator i=cells.begin(); i!=cells.end(); i++) {
     delete *i;
+  }
   cells.clear();
   Cell::NCells() = 0;
   delete boundary_polygon;
   // Clear walls
   for (list<Wall *>::iterator i=walls.begin(); i!=walls.end(); i++) {
     delete *i;
+  }
   walls.clear();
   WallBase::nwalls = 0;
   //tmp_walls->clear();
   shuffled_cells.clear();
   shuffled_nodes.clear();
   //Cell::ncells=0;
   /*    Cell::ClearNCells();
 	Node::nnodes=0;
 	cells.clear();
 	nodes.clear();
 	shuffled_cells.clear();
 	shuffled_nodes.clear();
 	node_insertion_queue.empty();
 	cerr << "Meshed cleared: cells: " << cells.size() << ", nodes: " << nodes.size() << endl;
   */
 #ifdef QDEBUG
   qDebug() << "cells.size() = " << cells.size() << endl;
   qDebug() << "walls.size() = " << walls.size() << endl;
   qDebug() << "nodes.size() = " << nodes.size() << endl;
 #endif
+}
 double Mesh::DisplaceNodes(void) {
   MyUrand r(shuffled_nodes.size());
   random_shuffle(shuffled_nodes.begin(),shuffled_nodes.end(),r);
   double sum_dh=0;
   list<DeltaIntgrl> delta_intgrl_list;
   for_each( node_sets.begin(), node_sets.end(), mem_fun( &NodeSet::ResetDone ) );
   for (vector<Node *>::const_iterator i=shuffled_nodes.begin(); i!=shuffled_nodes.end(); i++) {
     //int n=shuffled_nodes[*i];
     Node &node(**i);
     // Do not allow displacement if fixed
     //if (node.fixed) continue;
     if (node.DeadP()) continue;
     // Attempt to move this cell in a random direction
     double rx=par.mc_stepsize*(RANDOM()-0.5); // was 100.
     double ry=par.mc_stepsize*(RANDOM()-0.5);
     // Uniform with a circle of radius par.mc_stepsize
     /* double r = RANDOM() * par.mc_stepsize;
        double th = RANDOM()*2*Pi;
        double rx = r * cos(th);
        double ry = r * sin(th);
     */
     Vector new_p(node.x+rx,node.y+ry,0);
     Vector old_p(node.x,node.y,0);
     /* if (node.boundary  && boundary_polygon->MoveSelfIntersectsP(n,  new_p )) {
     // reject if move of boundary results in self intersection
     continue;
     }*/
     if (node.node_set) {
       // move each node set only once
       if (!node.node_set->DoneP())
 	node.node_set->AttemptMove(rx,ry);
     } else {
       // for all cells to which this node belongs:
       //   calculate energy difference
       double area_dh=0.;
       double length_dh=0.;
       double bending_dh=0.;
       double cell_length_dh=0.;
       double alignment_dh=0.;
       double old_l1=0.,old_l2=0.,new_l1=0.,new_l2=0.;
       double sum_stiff=0.;
       double dh=0.;
       for (list<Neighbor>::const_iterator cit=node.owners.begin(); cit!=node.owners.end(); cit++) {
 	//Cell &c=m->getCell(cit->cell);
 	//Cell &c=cit->cell->BoundaryPolP()?*boundary_polygon:*(cit->cell);
 	Cell &c=*((Cell *)(cit->cell));
-	//Cell &c=cells[cit->cell];
 	if (c.MoveSelfIntersectsP(&node,  new_p )) {
 	  // reject if move results in self intersection
 	  //
 	  // I know: using goto's is bad practice... except when jumping out
 	  // of deeply nested loops :-)
 	  //cerr << "Rejecting due to self-intersection\n";
 	  goto next_node;
+	}
 	// summing stiffnesses of cells. Move has to overcome this minimum required energy.
 	sum_stiff += c.stiffness;
 	// area - (area after displacement): see notes for derivation
 	//Vector i_min_1 = m->getNode(cit->nb1);
 	Vector i_min_1 = *(cit->nb1);
 	//Vector i_plus_1 = m->getNode(cit->nb2);
 	Vector i_plus_1 = *(cit->nb2);
 	// We must double the weights for the perimeter (otherwise they start bulging...)
 	double w1, w2;
 	if (node.boundary && cit->nb1->boundary)
 #ifdef FLEMING
 	  w1 = par.rel_perimeter_stiffness;
 #else
 	w1=2;
 #endif
 	else
 	  w1 = 1;
 	if (node.boundary && cit->nb2->boundary)
 #ifdef FLEMING
 	  w2 = par.rel_perimeter_stiffness;
 #else
 	w2 = 2;
 #endif
 	else
 	  w2 = 1;
 	//if (cit->cell>=0) {
 	if (!cit->cell->BoundaryPolP()) {
 	  double delta_A = 0.5 * ( ( new_p.x - old_p.x ) * (i_min_1.y - i_plus_1.y) +
 				   ( new_p.y - old_p.y ) * ( i_plus_1.x - i_min_1.x ) );
 	  area_dh +=  delta_A * (2 * c.target_area - 2 * c.area + delta_A);
 	  // cell length constraint
 	  // expensive and not always needed
 	  // so we check the value of lambda_celllength
 	  if (/* par.lambda_celllength */  cit->cell->lambda_celllength) {
 	    double delta_ix =
 	      (i_min_1.x + new_p.x)
 	      * (new_p.x * i_min_1.y- i_min_1.x * new_p.y) +
 	      (new_p.x + i_plus_1.x)
 	      * (i_plus_1.x * new_p.y- new_p.x * i_plus_1.y) -
 	      (i_min_1.x + old_p.x)
 	      * (old_p.x * i_min_1.y- i_min_1.x * old_p.y) -
 	      (old_p.x + i_plus_1.x)
 	      * (i_plus_1.x * old_p.y - old_p.x * i_plus_1.y);
 	    double delta_iy =
 	      (i_min_1.y + new_p.y)
 	      * (new_p.x * i_min_1.y- i_min_1.x * new_p.y) +
 	      (new_p.y + i_plus_1.y)
 	      * (i_plus_1.x * new_p.y- new_p.x * i_plus_1.y) -
 	      (i_min_1.y + old_p.y)
 	      * (old_p.x * i_min_1.y- i_min_1.x * old_p.y) -
 	      (old_p.y + i_plus_1.y)
 	      * (i_plus_1.x * old_p.y - old_p.x * i_plus_1.y);
 	    double delta_ixx =
 	      (new_p.x*new_p.x+
 	       i_min_1.x*new_p.x+
 	       i_min_1.x*i_min_1.x ) *
 	      (new_p.x*i_min_1.y - i_min_1.x*new_p.y) +
 	      (i_plus_1.x*i_plus_1.x+
 	       new_p.x*i_plus_1.x+
 	       new_p.x*new_p.x ) *
 	      (i_plus_1.x*new_p.y - new_p.x*i_plus_1.y) -
 	      (old_p.x*old_p.x+
 	       i_min_1.x*old_p.x+
 	       i_min_1.x*i_min_1.x ) *
 	      (old_p.x*i_min_1.y - i_min_1.x*old_p.y) -
 	      (i_plus_1.x*i_plus_1.x+
 	       old_p.x*i_plus_1.x+
 	       old_p.x*old_p.x ) *
 	      (i_plus_1.x*old_p.y - old_p.x*i_plus_1.y);
 	    double delta_ixy =
 	      (i_min_1.x*new_p.y-
 	       new_p.x*i_min_1.y)*
 	      (new_p.x*(2*new_p.y+i_min_1.y)+
 	       i_min_1.x*(new_p.y+2*i_min_1.y)) +
 	      (new_p.x*i_plus_1.y-
 	       i_plus_1.x*new_p.y)*
 	      (i_plus_1.x*(2*i_plus_1.y+new_p.y)+
 	       new_p.x*(i_plus_1.y+2*new_p.y)) -
@@ @@ -684,505 +671,456 @@ double Mesh::DisplaceNodes(void) { @@
 	       i_min_1.x*(old_p.y+2*i_min_1.y)) -
 	      (old_p.x*i_plus_1.y-
 	       i_plus_1.x*old_p.y)*
 	      (i_plus_1.x*(2*i_plus_1.y+old_p.y)+
 	       old_p.x*(i_plus_1.y+2*old_p.y));
 	    double delta_iyy =
 	      (new_p.x*i_min_1.y-
 	       i_min_1.x*new_p.y)*
 	      (new_p.y*new_p.y+
 	       i_min_1.y*new_p.y+
 	       i_min_1.y*i_min_1.y ) +
 	      (i_plus_1.x*new_p.y-
 	       new_p.x*i_plus_1.y)*
 	      (i_plus_1.y*i_plus_1.y+
 	       new_p.y*i_plus_1.y+
 	       new_p.y*new_p.y ) -
 	      (old_p.x*i_min_1.y-
 	       i_min_1.x*old_p.y)*
 	      (old_p.y*old_p.y+
 	       i_min_1.y*old_p.y+
 	       i_min_1.y*i_min_1.y ) -
 	      (i_plus_1.x*old_p.y-
 	       old_p.x*i_plus_1.y)*
 	      (i_plus_1.y*i_plus_1.y+
 	       old_p.y*i_plus_1.y+
 	       old_p.y*old_p.y );
 	    delta_intgrl_list.push_back(DeltaIntgrl(delta_A,delta_ix,delta_iy,delta_ixx,delta_ixy,delta_iyy));
 	    Vector old_axis;
 	    double old_celllength = c.Length(&old_axis);
 	    old_axis=old_axis.Normalised().Perp2D();
 	    // calculate length after proposed update
 	    double intrx=(c.intgrl_x-delta_ix)/6.;
 	    double intry=(c.intgrl_y-delta_iy)/6.;
 	    double ixx=((c.intgrl_xx-delta_ixx)/12.)-(intrx*intrx)/(c.area-delta_A);
 	    double ixy=((c.intgrl_xy-delta_ixy)/24.)+(intrx*intry)/(c.area-delta_A);
 	    double iyy=((c.intgrl_yy-delta_iyy)/12.)-(intry*intry)/(c.area-delta_A);
 	    double rhs1=(ixx+iyy)/2., rhs2=sqrt( (ixx-iyy)*(ixx-iyy)+4*ixy*ixy )/2.;
 	    double lambda_b=rhs1+rhs2;
 	    double new_celllength=4*sqrt(lambda_b/(c.area-delta_A));
 	    //cerr << "new_celllength = "  << new_celllength << endl;
 	    //cerr << "target_length = "  << c.target_length << endl;
 	    cell_length_dh += c.lambda_celllength * ( DSQR(c.target_length - new_celllength) - DSQR(c.target_length-old_celllength) );
 	    Vector norm_long_axis(lambda_b - ixx, ixy, 0);
 	    norm_long_axis.Normalise();
 	    double alignment_before = InnerProduct(old_axis, c.cellvec);
 	    double alignment_after = InnerProduct(norm_long_axis, c.cellvec);
 	    /* cerr << "Delta alignment = " << alignment_before - alignment_after << endl;
 	       cerr << "Old alignment is " << alignment_before << ", new alignment is " << alignment_after << endl;
 	       cerr << "Old axis is " << old_axis << ", new axis is " << norm_long_axis << endl;
 	    */
 	    alignment_dh += alignment_before - alignment_after;
 	    /* cerr << "alignment_dh  = " << alignment_dh << endl;
 	       cerr << "cellvec = " << c.cellvec << endl;*/
 	  } else {
 	    // if we have no length constraint, still need to update area
 	    delta_intgrl_list.push_back(DeltaIntgrl(delta_A,0,0,0,0,0));
+	  }
 	  old_l1=(old_p-i_min_1).Norm();
 	  old_l2=(old_p-i_plus_1).Norm();
 	  new_l1=(new_p-i_min_1).Norm();
 	  new_l2=(new_p-i_plus_1).Norm();
 	  static int count=0;
 	  // Insertion of nodes (cell wall yielding)
 	  if (!node.fixed) {
 	    if (old_l1 > 4*Node::target_length && !cit->nb1->fixed) {
 	      node_insertion_queue.push( Edge(cit->nb1, &node) );
+	    }
 	    if (old_l2 > 4*Node::target_length && !cit->nb2->fixed) {
 	      node_insertion_queue.push( Edge(&node, cit->nb2 ) );
+	    }
 	    count++;
 	    /*length_dh += 2*Node::target_length * (old_l1 + old_l2 - new_l1 - new_l2)
 	      + DSQR(new_l1) - DSQR(old_l1) + DSQR(new_l2) - DSQR(old_l2);*/
+	  }
 	  /* length_dh += 2*Node::target_length * ( w1*(old_l1 - new_l1) +
 	     w2*(old_l2 - new_l2) ) +
 	     w1*(DSQR(new_l1)
 	     - DSQR(old_l1))
 	     + w2*(DSQR(new_l2)
 	     - DSQR(old_l2)); */
 	  /*	if (c.cellvec.ManhattanNorm()!=0) {
 	  // wall element length constraint
 	  double old_aniso1, old_aniso2;
 	  double new_aniso1, new_aniso2;
 	  // anisotropic expansion?
 	  old_aniso1 = 1 + par.lambda_aniso*(1 - fabs(InnerProduct((old_p-i_min_1), c.cellvec))/old_l1);
 	  old_aniso2 = 1 + par.lambda_aniso*(1 - fabs(InnerProduct((old_p-i_plus_1), c.cellvec))/old_l2);
 	  new_aniso1 = 1 + par.lambda_aniso*(1 - fabs(InnerProduct((new_p-i_min_1),  c.cellvec))/new_l1);
 	  new_aniso2 = 1 + par.lambda_aniso*(1 - fabs(InnerProduct((new_p-i_plus_1), c.cellvec))/new_l2);
 	  length_dh += w1 * ( new_aniso1 * DSQR(new_l1 - Node::target_length) -
 	  old_aniso1 * DSQR(old_l1 - Node::target_length) )
 	  +  w2 * ( new_aniso2 * DSQR(new_l2 - Node::target_length) -
 	  old_aniso2 * DSQR(old_l2 - Node::target_length) );
 	  } else {
 	  */
 	  length_dh += 2*Node::target_length * ( w1*(old_l1 - new_l1) +
 						 w2*(old_l2 - new_l2) ) +
 	    w1*(DSQR(new_l1)
 		- DSQR(old_l1))
 	    + w2*(DSQR(new_l2)
 		  - DSQR(old_l2));
 	  //}
+	}
 	// bending energy also holds for outer boundary
 	// first implementation. Can probably be done more efficiently
 	// calculate circumcenter radius (gives local curvature)
 	// the ideal bending state is flat... (K=0)
 	// if (cit->cell==-1 && node.cells.size()>2 /* boundary_pol, cell and a second cell */)  {
+	{
+		  {
 	  // strong bending energy to resist "cleaving" by division planes
 	  double r1, r2, xc, yc;
 	  CircumCircle(i_min_1.x, i_min_1.y, old_p.x, old_p.y, i_plus_1.x, i_plus_1.y,
 		       &xc,&yc,&r1);
 	  CircumCircle(i_min_1.x, i_min_1.y, new_p.x, new_p.y, i_plus_1.x, i_plus_1.y,
 		       &xc,&yc, &r2);
 	  if (r1<0 || r2<0) {
 	    MyWarning::warning("r1 = %f, r2 = %f",r1,r2);
+	  }
 	  bending_dh += DSQR(1/r2 - 1/r1);
 	  //bending_dh += ( DSQR(1/r2) - DSQR(1/r1) );
 	  //cerr << "bending_dh = " << par.bend_lambda*bending_dh << endl;
+	}
 	/*cerr << "Bending = " <<  ( DSQR(1/r2) - DSQR(1/r1))  << endl;
 	  cerr << node.index << ": " << bending_dh << " (" << r1 << ", " << r2 << ") " << cit->nb1 << ", " << cit->nb2 << ")" << endl;
 	  }*/
 	/*else
 	  bending_dh += ( DSQR(1/r2) - DSQR(1/r1) );*/
 	/*if (cit->cell==-1) {
 	  cerr << node.index << ": " << bending_dh << " (" << r1 << ", " << r2 << ") " << cit->nb1 << ", " << cit->nb2 << ")" << endl;
 	  }*/
 	//bending_dh += r1 - r2;
+      }
       //const double bend_lambda = 100000;
       //const double bend_lambda = 0;
       /* double dh = //(area_dev_sum_after - area_dev_sum_before) +
 	 area_dh + par.lambda_celllength * cell_length_dh +
 	 par.lambda_length * length_dh + par.bend_lambda * bending_dh + par.alignment_lambda * alignment_dh;*/
       dh = //(area_dev_sum_after - area_dev_sum_before) +
 	area_dh + cell_length_dh +
       dh = 	area_dh + cell_length_dh +
 	par.lambda_length * length_dh + par.bend_lambda * bending_dh + par.alignment_lambda * alignment_dh;
       //cerr << "cell_length_dh = " << par.lambda_celllength * cell_length_dh << endl;
       //(length_constraint_after - length_constraint_before);
          //(length_constraint_after - length_constraint_before);
       if (node.fixed) {
 	// search the fixed cell to which this node belongs
 	// and displace these cells as a whole
 	// WARNING: undefined things will happen for connected fixed cells...
 	for (list<Neighbor>::iterator c=node.owners.begin(); c!=node.owners.end(); c++) {
 	  if (!c->cell->BoundaryPolP() && c->cell->FixedP()) {
 	    sum_dh+=c->cell->Displace(rx,ry,0);
+	  }
+	}
       } else {
 	if (dh<-sum_stiff || RANDOM()<exp((-dh-sum_stiff)/par.T)) {
 	  // update areas of cells
 	  list<DeltaIntgrl>::const_iterator di_it = delta_intgrl_list.begin();
 	  for (list<Neighbor>::iterator cit=node.owners.begin(); cit!=node.owners.end(); ( cit++) ) {
 	    if (!cit->cell->BoundaryPolP()) {
 	      cit->cell->area -= di_it->area;
 	      if (par.lambda_celllength) {
 		cit->cell->intgrl_x -= di_it->ix;
 		cit->cell->intgrl_y -= di_it->iy;
 		cit->cell->intgrl_xx -= di_it->ixx;
 		cit->cell->intgrl_xy -= di_it->ixy;
 		cit->cell->intgrl_yy -= di_it->iyy;
+	      }
 	      di_it++;
+	    }
+	  }
 	  double old_nodex, old_nodey;
 	  old_nodex=node.x;
 	  old_nodey=node.y;
 	  node.x = new_p.x;
 	  node.y = new_p.y;
 	  for (list<Neighbor>::iterator cit=node.owners.begin();
 	       cit!=node.owners.end();
 	       ( cit++) ) {
 	    /*   if (cit->cell >= 0 && cells[cit->cell].SelfIntersect()) {
 		 node.x = old_nodex;
 		 node.y = old_nodey;
 		 goto next_node;
 		 }*/
+	  }
 	  sum_dh += dh;
+	}
+      }
+    }
   next_node:
     delta_intgrl_list.clear();//dA_list.clear();
+  }
   return sum_dh;
+}
 void Mesh::InsertNode(Edge &e) {
   // Construct a new node in the middle of the edge
   Node *new_node = AddNode( new Node ( ( *e.first + *e.second )/2 ) );
   // if new node is inserted into the boundary
   // it will be part of the boundary, fixed, and source, too
   // The new node is part of the boundary only if both its neighbors are boundary nodes and the boundray proceeds from first to second.
   new_node->boundary = (e.first->BoundaryP() && e.first->BoundaryP()) && ((findNextBoundaryNode(e.first))->Index() == e.second->Index());
   new_node->fixed = e.first->fixed && e.second->fixed;
   new_node->sam = new_node->boundary && (e.first->sam || e.second->sam);
   // insert it into the boundary polygon;
   /* if (new_node->boundary) {
   // find the position of the first node in the boundary
   list<Node *>::iterator ins_pos = find
   (boundary_polygon->nodes.begin(),
   boundary_polygon->nodes.end(),
   e.first);
   // ... second node comes before or after it ...
   if (*(++ins_pos!=boundary_polygon->nodes.end()?
   ins_pos:boundary_polygon->nodes.begin())!=e.second) {
   boundary_polygon->nodes.insert(((ins_pos--)!=boundary_polygon->nodes.begin()?ins_pos:(--boundary_polygon->nodes.end())), new_node);
   // .. set the neighbors of the new node ...
   // in this case e.second and e.first are inverted
   new_node->owners.push_back( Neighbor(boundary_polygon, e.second, e.first ) );
   //cerr << "pushing back " << Neighbor(boundary_polygon->index, e.second, e.first ) << endl;
   } else {
   // insert before second node, so leave ins_pos as it is,
   // that is incremented
   boundary_polygon->nodes.insert(ins_pos, new_node);
   // .. set the neighbors of the new node ...
   new_node->owners.push_back( Neighbor(boundary_polygon, e.first, e.second ) );
   // cerr << "pushing back " << Neighbor(boundary_polygon->index, e.second, e.first ) << endl;
+  }
   }*/
   list<Neighbor> owners;
   // push all cells owning the two nodes of the divided edges
   // onto a list
   copy(e.first->owners.begin(),
        e.first->owners.end(),
        back_inserter(owners));
   copy(e.second->owners.begin(),
        e.second->owners.end(),
        back_inserter(owners));
   //copy(owners.begin(), owners.end(), ostream_iterator<Neighbor>(cerr, " "));
   //cerr << endl;
   // sort the nodes
   owners.sort( mem_fun_ref( &Neighbor::Cmp ) );
   //  extern ofstream debug_stream;
   //  debug_stream << "Nodes " << e.first << " and " << e.second << endl;
   //  copy(owners.begin(), owners.end(), ostream_iterator<Neighbor>(debug_stream, " "));
   //  debug_stream << endl;
   // the duplicates in this list indicate cells owning this edge
   list<Neighbor>::iterator c=owners.begin();
   while (c!=owners.end()) {
     c=adjacent_find(c,owners.end(),  neighbor_cell_eq);
     if (c!=owners.end()) { // else break;
       //      debug_stream << "Cell " << c->cell << " owns Edge " << e << endl;
       //if (c->cell>=0) {
       //if (!c->cell->BoundaryPolP()) {
       // find the position of the edge's first node in cell c...
       list<Node *>::iterator ins_pos = find
 	(c->cell->nodes.begin(),
 	 c->cell->nodes.end(),
 	 e.first);
       // ... second node comes before or after it ...
       // XXXX probably this test is always false XXXX: No, works okay.
       if (*(++ins_pos!=c->cell->nodes.end()?
 	    ins_pos:c->cell->nodes.begin())!=e.second) {
 	c->cell->nodes.insert(((ins_pos--)!=c->cell->nodes.begin()?ins_pos:(--c->cell->nodes.end())), new_node);
 	//cells[c->cell].nodes.insert(--ins_pos, new_node->index);
 	// .. set the neighbors of the new node ...
 	// in this case e.second and e.first are inverted
 	//  cerr << "Inverted\n";
 	new_node->owners.push_back( Neighbor(c->cell, e.second, e.first ) );
       } else {
 	// insert before second node, so leave ins_pos as it is,
 	// that is incremented
 	c->cell->nodes.insert(ins_pos, new_node);
 	// .. set the neighbors of the new node ...
 	// cerr << "Not inverted\n";
 	new_node->owners.push_back( Neighbor(c->cell, e.first, e.second ) );
+      }
       // redo the neighbors:
       //}
       // - find cell c among owners of Node e.first
       list<Neighbor>::iterator cpos=
 	find_if( e.first->owners.begin(),
 		 e.first->owners.end(),
 		 bind2nd( mem_fun_ref(&Neighbor::CellEquals), c->cell->Index()) );
       // - correct the record
       if (cpos->nb1 == e.second) {
 	cpos->nb1 = new_node;
       } else
 	if (cpos->nb2 == e.second) {
 	  cpos->nb2 = new_node;
+	}
       // - same for Node e.second
       cpos=
 	find_if( e.second->owners.begin(),
 		 e.second->owners.end(),
 		 bind2nd( mem_fun_ref(&Neighbor::CellEquals), c->cell->Index()) );
       // - correct the record
       if (cpos->nb1 == e.first) {
 	cpos->nb1 = new_node;
       } else
 	if (cpos->nb2 == e.first) {
 	  cpos->nb2 = new_node;
+	}
     } else break;
     c++;
+  }
   // Repair neighborhood lists in a second loop, to make sure all
   // `administration' is up to date
   while (c!=owners.end()) {
     c=adjacent_find(c,owners.end(),  neighbor_cell_eq);
     // repair neighborhood lists of cell and Wall lists
-    //if (c->cell>=0) {
     if (!c->cell->BoundaryPolP()) {
       c->cell->ConstructNeighborList();
-      //      debug_stream << "Repairing NeighborList of " << c->cell << endl;
+    }
     c++;
+  }
-  //  debug_stream.flush();
+}
 /*
   Calculate circumcircle of triangle (x1,y1), (x2,y2), (x3,y3)
   The circumcircle centre is returned in (xc,yc) and the radius in r
   NOTE: A point on the edge is inside the circumcircle
 */
 void Mesh::CircumCircle(double x1,double y1,double x2,double y2,double x3,double y3,
 			double *xc,double *yc,double *r)
+{
   double m1,m2,mx1,mx2,my1,my2;
   double dx,dy,rsqr;
   /* Check for coincident points */
   /*if (abs(y1-y2) < TINY && abs(y2-y3) < TINY)
     return(false);*/
   if (abs(y2-y1) < TINY) {
     m2 = - (x3-x2) / (y3-y2);
     mx2 = (x2 + x3) / 2.0;
     my2 = (y2 + y3) / 2.0;
     *xc = (x2 + x1) / 2.0;
     *yc = m2 * (*xc - mx2) + my2;
   } else if (abs(y3-y2) < TINY) {
     m1 = - (x2-x1) / (y2-y1);
     mx1 = (x1 + x2) / 2.0;
     my1 = (y1 + y2) / 2.0;
     *xc = (x3 + x2) / 2.0;
     *yc = m1 * (*xc - mx1) + my1;
   } else {
     m1 = - (x2-x1) / (y2-y1);
     m2 = - (x3-x2) / (y3-y2);
     mx1 = (x1 + x2) / 2.0;
     mx2 = (x2 + x3) / 2.0;
     my1 = (y1 + y2) / 2.0;
     my2 = (y2 + y3) / 2.0;
     *xc = (m1 * mx1 - m2 * mx2 + my2 - my1) / (m1 - m2);
     *yc = m1 * (*xc - mx1) + my1;
+  }
   dx = x2 - *xc;
   dy = y2 - *yc;
   rsqr = dx*dx + dy*dy;
   *r = sqrt(rsqr);
   return;
   // Suggested
   // return((drsqr <= rsqr + EPSILON) ? TRUE : FALSE);
+}
 //
 // return the total amount of chemical "ch" in the leaf
 double Mesh::SumChemical(int ch) {
   double sum=0.;
   for (vector<Cell *>::iterator i=cells.begin(); i!=cells.end(); i++) {
     sum+=(*i)->chem[ch];
+  }
   return sum;
+}
 void Mesh::CleanUpCellNodeLists(void) {
   typedef vector <vector<Cell *>::iterator> CellItVect;
   CellItVect cellstoberemoved;
   vector<int> cellind;
   // Start of by removing all stale walls.
   //DeleteLooseWalls();
   // collect all dead cells that need to be removed from the simulation
   for (vector<Cell *>::iterator i=cells.begin(); i!=cells.end(); i++) {
     if ((*i)->DeadP()) {
       // collect the iterators
       cellstoberemoved.push_back(i);
       // collect the indices
       cellind.push_back((*i)->index);
     } else {
       // Remove pointers to dead Walls
       for (list<Wall *>::iterator w=(*i)->walls.begin(); w!=(*i)->walls.end(); w++) {
 	if ((*w)->DeadP()) {
 	  (*w)=0;
+	}
+      }
       (*i)->walls.remove(0);
+    }
+  }
   // Remove pointers to dead Walls from BoundaryPolygon
   for (list<Wall *>::iterator w=boundary_polygon->walls.begin(); w!=boundary_polygon->walls.end(); w++) {
     if ((*w)->DeadP()) {
@@ @@ -1385,193 +1323,193 @@ void Mesh::RepairBoundaryPolygon(void) { @@
     node->Unmark(); // remove marks, we need them to determine if we have closed the circle
     list<Neighbor>::iterator boundary_ref_pos;
     if ((boundary_ref_pos = find_if (node->owners.begin(), node->owners.end(),
 				     bind2nd(mem_fun_ref(&Neighbor::CellEquals), -1))) != node->owners.end()) {
       // i.e. if one of the node's owners is the boundary polygon
       node->owners.erase(boundary_ref_pos); // remove the reference
+    }
+  }
   // Step 3: Search for the first boundary node.  We reconstruct the
   // boundary polygon by moving along the boundary nodes until we've
   // encircled the polygon. Since manually adding nodes may have
   // turned nodes previously along the boundary into internal nodes,
   // we search through all the node until we find first boundary node
   // and proceed from there. If findNextBoundaryNode() returns a node
   // other than the one passed to it, the original node is the first
   // boundary node.
   foreach (Node* node, nodes) {
     if ((findNextBoundaryNode(node))->index != node->index){
       next_boundary_node = node;
       break;
+    }
+  }
   // We have a problem if we arrive here without having found a boundary node.
   if (!next_boundary_node) throw("Cannot find a boundary node!.");
   // Reconstruct the list of boundary polygon nodes.
   do {
     boundary_node = next_boundary_node;
     boundary_node->Mark();
     boundary_polygon->nodes.push_back(boundary_node);
     next_boundary_node = findNextBoundaryNode(boundary_node);
   } while ( !next_boundary_node->Marked() );
   // Create a set containing the reconstructed boundary polygon nodes' Indices.
   for (list<Node *>::iterator it = boundary_polygon->nodes.begin(); it!=boundary_polygon->nodes.end(); ++it) {
     repaired_boundary_nodes.insert((*it)->Index());
+  }
   // Calculate the difference between the original and repaired sets of boundary nodes
   // yielding the set of nodes that are no longer part of the boundary polygon.
   set_difference(original_boundary_nodes.begin(), original_boundary_nodes.end(),
                  repaired_boundary_nodes.begin(), repaired_boundary_nodes.end(), back_inserter(difference));
   // Tell each node in the difference that it's no longer part of the boundary polygon
   vector<Node *>::iterator internal_node_it;
   foreach (int i, difference){
     internal_node_it = find_if (nodes.begin(), nodes.end(), bind2nd(mem_fun(&Node::IndexEquals), i));
     internal_node = *internal_node_it; // dereference the itterator to get to the node pointer
     if (!internal_node) throw("Found a null Node pointer.");
     internal_node->UnsetBoundary();
+  }
   boundary_polygon->ConstructConnections();
   for (list<Wall *>::iterator w=boundary_polygon->walls.begin(); w!=boundary_polygon->walls.end(); w++) {
     if ((*w)->DeadP()) {
       (*w)=0;
+    }
+  }
   boundary_polygon->walls.remove(0);
   boundary_polygon->ConstructNeighborList();
 #ifdef QDEBUG
   qDebug() << "Repaired Boundary Polygon node indices: ";
   foreach (Node* node, boundary_polygon->nodes){
     qDebug() << node->Index() << " " ;
+  }
   qDebug() << endl ;
 #ifdef _undefined_
   qDebug() << "NODES:" << endl;
   foreach(Node* node, nodes) {
     qDebug() << *node;
+  }
   qDebug() << endl;
   qDebug() << "WALLS:" << endl;
   foreach(Wall* wall, walls) {
     qDebug() << *wall;
+  }
   qDebug() << endl;
   qDebug() << "CELLS:" << endl;
   foreach(Cell* cell, cells) {
     qDebug() << *cell;
+  }
   qDebug() << endl;
 #endif
 #endif
+}
 Node* Mesh::findNextBoundaryNode(Node* boundary_node) {
   bool found_next_boundary_node = false;
-  Node *next_boundary_node = NULL;
+  Node *next_boundary_node = 0;
   set<int> boundary_node_owners; // This is a list of the current boundary node's owners' Ids
   vector<int> neighborIds; // A list of the current boundary node's owners' 2nd neighbor Ids
   vector<set<int> *>  nodeOwners; // A vector of set pointers where each set contains the owner Ids of the nodes in the neighborIds list.
   vector<int> intersection; // set intersection result
   // The next boundary node is that which has only one owner in common with the current boundary node
   for (list<Neighbor>::iterator it=boundary_node->owners.begin(); it!=boundary_node->owners.end(); ++it) {
     if (it->cell->Index() != -1) boundary_node_owners.insert(it->cell->Index()); // Save each of the current boundary node's owners' Ids - except the boundary polygon
     set<int> *owners = new set<int>; // create a set to hold a 2nd neighbor's owners' Ids
     nodeOwners.push_back(owners);
     neighborIds.push_back(it->nb2->Index());
     foreach(Neighbor neighbor, it->nb2->owners){
       if (neighbor.cell->Index() != -1) owners->insert(neighbor.cell->Index()); // Save second neighbors' owners' Ids - except the boundary polygon
+    }
+  }
   vector<int>::iterator itt = neighborIds.begin();
   vector<set<int> *>::iterator it = nodeOwners.begin();
 #ifdef QDEBUG
   qDebug() << "Boundary node: " <<  boundary_node->Index() << " is owned by the following cells: ";
   foreach (int i, boundary_node_owners){
     qDebug() << i << "  ";
+  }
   qDebug() << endl;
 #endif
   for (; it < nodeOwners.end(); it++, itt++) {
     intersection.clear();
     set_intersection(boundary_node_owners.begin(), boundary_node_owners.end(), (*it)->begin(), (*it)->end(), back_inserter(intersection));
 #ifdef QDEBUG
     qDebug() << "The intersection of the boundary node(" << boundary_node->Index() << ") owners and its 2nd neighbor(" <<  *itt << ") owners is: ";
     foreach (int i, intersection){
       qDebug() << i << "  ";
+    }
     qDebug() << endl;
 #endif
     if (intersection.size() == 1){
       found_next_boundary_node = true;
       vector<Node *>::iterator next_boundary_node_it = find_if (nodes.begin(), nodes.end(), bind2nd(mem_fun(&Node::IndexEquals), *itt));
       next_boundary_node = *next_boundary_node_it; // defeference the itterator to get to the node pointer
 #ifdef QDEBUG
       qDebug() << "The Current boundary node is: " << boundary_node->Index()
 	       << ". The Next boundary node is: " << *itt << ((next_boundary_node->Marked()) ? " Marked" : " Unmarked") << endl << endl;
 #endif
       break;
+    }
+  }
 #ifdef QDEBUG
   if (!found_next_boundary_node) {
     qDebug() << "OOPS! Didn't find the next boundrary node!" << endl;
+  }
 #endif
   return next_boundary_node;
+}
 void Mesh::CleanUpWalls(void) {
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
     if ((*w)->DeadP()) {
       delete *w;
       (*w)=0;
+    }
+  }
   walls.remove(0);
+}
 void Mesh::Rotate(double angle, Vector center) {
   // Rotate the mesh over the angle "angle", relative to center point "center".
   Matrix rotmat;
   rotmat.Rot2D(angle);
   for (vector<Node *>::iterator n=nodes.begin(); n!=nodes.end(); n++) {
     (*n)->setPos ( rotmat * ( *(*n) - center ) + center );
+  }
+}
 void Mesh::PrintWallList( void ) {
   transform ( walls.begin(), walls.end(), ostream_iterator<Wall>(cerr, "\n"), deref_ptr<Wall> );
+}
 #include <QString>
 //#include "forwardeuler.h"
 #include "rungekutta.h"
 class SolveMesh : public RungeKutta {
@@ @@ -1830,195 +1768,192 @@ void Mesh::setValues(double x, double *y @@
       (*w)->setTransporters1(ch,y[i+ch]);
+    }
     i+=nchems;
     for (int ch=0;ch<nchems;ch++) {
       (*w)->setTransporters2(ch,y[i+ch]);
+    }
     i+=nchems;
+  }
   emit_count++;
+}
 double *Mesh::getValues(int *neqs) {
   int nwalls = walls.size();
   int ncells = cells.size();
   int nchems = Cell::NChem();
   // two eqs per chemical for each wall, and one eq per chemical for each cell
   // This is for generality. For a specific model you may optimize
   // this by removing superfluous (empty) equations.
   (*neqs) = 2 * nwalls * nchems + ncells * nchems;
   // Layout of derivatives: cells [ chem1 ... chem n]  walls [ [ w1(chem 1) ... w1(chem n) ] [ w2(chem 1) ... w2(chem n) ] ]
   static double *values = 0;
   if (values!=0) { delete[] values; }
   values = new double[*neqs];
   int i=0;
   for (vector<Cell *>::iterator c=cells.begin(); c!=cells.end(); c++) {
     for (int ch=0;ch<nchems;ch++) {
       values[i+ch]=(*c)->Chemical(ch);
+    }
     i+=nchems;
+  }
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
     for (int ch=0;ch<nchems;ch++) {
       values[i+ch]=(*w)->Transporters1(ch);
+    }
     i+=nchems;
     for (int ch=0;ch<nchems;ch++) {
       values[i+ch]=(*w)->Transporters2(ch);
+    }
     i+=nchems;
+  }
   return values;
+}
 void Mesh::DrawNodes(QGraphicsScene *c) const {
   for (vector<Node *>::const_iterator n=nodes.begin(); n!=nodes.end(); n++) {
     Node *i=*n;
     NodeItem *item = new NodeItem ( &(*i), c );
     item->setColor();
     item->setZValue(5);
     item->show();
     item ->setPos(((Cell::offset[0]+i->x)*Cell::factor),
 		  ((Cell::offset[1]+i->y)*Cell::factor) );
+  }
+}
 /*! Returns the sum of protein "ch" of a cycling protein in cells and walls */
 double Mesh::CalcProtCellsWalls(int ch) const {
   double sum_prot=0.;
   // At membranes
   for (list<Wall *>::const_iterator w=walls.begin(); w!=walls.end(); w++) {
     sum_prot += (*w)->Transporters1(ch);
     sum_prot += (*w)->Transporters2(ch);
+  }
   // At cells
   for (vector<Cell *>::const_iterator c=cells.begin(); c!=cells.end(); c++) {
     sum_prot += (*c)->Chemical(ch);
+  }
   return sum_prot;
+}
 void Mesh::SettoInitVals(void) {
   vector<double> clean_chem(Cell::NChem());
   vector<double> clean_transporters(Cell::NChem());
   for (int i=0;i<Cell::NChem();i++) {
     clean_transporters[i]=0.;
     clean_chem[i]=par.initval[i];
+  }
   // Amount of PIN1
   //clean_chem[1] = 0.;
   CleanChemicals(clean_chem);
   CleanTransporters(clean_transporters);
+}
 string Mesh::getTimeHours(void) const {
   int hours = (int)(time / 3600);
   int mins = (int)((time - hours * 3600)/60);
   int secs = (int)((time - hours * 3600 - mins * 60));
   ostringstream tstr;
   tstr << hours << " h " << mins << " m " << secs << " s";
   return tstr.str();
+}
 QVector<qreal> Mesh::VertexAngles(void) {
   QVector<qreal> angles;
   for (vector<Node *>::const_iterator n=nodes.begin(); n!=nodes.end(); n++) {
     if ((*n)->Value()>2 && !(*n)->BoundaryP() ) {
       angles+=(*n)->NeighbourAngles();
+    }
+  }
   return angles;
+}
 QVector< QPair<qreal,int> > Mesh::VertexAnglesValues(void) {
   QVector< QPair<qreal,int> > anglesvalues;
   for (vector<Node *>::const_iterator n=nodes.begin(); n!=nodes.end(); n++) {
     if ((*n)->Value()>2 && !(*n)->BoundaryP() ) {
       QVector<qreal> angles = (*n)->NeighbourAngles();
       int value_vertex = angles.size();
       for (QVector<qreal>::ConstIterator i=angles.begin(); i!=angles.end(); i++) {
 	anglesvalues += QPair< qreal, int > (*i, value_vertex);
+      }
+    }
+  }
   return anglesvalues;
+}
 void Mesh::Clean(void) {
 #ifdef QDEBUG
   qDebug() << "Freeing nodes" << endl;
 #endif
   for (vector<Node *>::iterator i=nodes.begin(); i!=nodes.end(); i++) {
     delete *i;
+  }
   nodes.clear();
   Node::nnodes=0;
 #ifdef QDEBUG
   qDebug() << "Freeing node sets" << endl;
 #endif
   for (vector<NodeSet *>::iterator i=node_sets.begin(); i!=node_sets.end(); i++) {
     delete *i;
+  }
   node_sets.clear();
 #ifdef QDEBUG
   qDebug() << "Freeing cells" << endl;
 #endif
   //CellsStaticDatamembers *old_static_data_mem = Cell::GetStaticDataMemberPointer();
   for (vector<Cell *>::iterator i=cells.begin(); i!=cells.end(); i++) {
     delete *i;
+  }
   //Cell::static_data_members = old_static_data_mem;
   cells.clear();
   Cell::NCells()=0;
   delete boundary_polygon; // (already deleted during cleaning of cells?)
 #ifdef QDEBUG
   qDebug() << "Freeing walls" << endl;
 #endif
   for (list<Wall *>::iterator i=walls.begin(); i!=walls.end(); i++) {
     delete *i;
+  }
   walls.clear();
   Wall::nwalls=0;
   node_insertion_queue.clear();
   shuffled_nodes.clear();
   shuffled_cells.clear();
   time = 0.0;
+}
 void Mesh::StandardInit(void) {
   boundary_polygon = new BoundaryPolygon();
   Cell &circle=CircularCell(0,0,10,10);
   circle.SetTargetArea(circle.CalcArea());
   circle.SetTargetLength(par.target_length);
   circle.SetLambdaLength(par.lambda_celllength);
   SetBaseArea();
   // clean up chemicals

src/mesh.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 // Cell derives from Vector, where Vector is simply used as a Vertex
 #ifndef _MESH_H_
 #define _MESH_H_
 #include <vector>
 #include <algorithm>
 #include <queue>
 #include <iterator>
 #include <functional>
 #ifdef QTGRAPHICS
 #include <QGraphicsScene>
 #endif
 #include "cell.h"
 #include "node.h"
 #include "simplugin.h"
 #include <QVector>
 #include <QPair>
 #include <QDebug>
 using namespace std;
 // new queue which rejects duplicate elements
 template<class T, class C = deque<T> > class unique_queue : public queue<T,C> {
  public:
  typedef typename C::value_type value_type;
  // reimplements push: reject element if it exists already
  void push(const value_type &x) {
    if (find (queue<T,C>::c.begin(),queue<T,C>::c.end(),x)==queue<T,C>::c.end()) {
      queue<T,C>::c.push_back(x);
+   }
+ }
  void clear(void) {
    queue<T,C>::c.clear();
+ }
 };
 template<class P> P& deref_ptr ( P *obj) { return *obj; }
 class Mesh {
   friend class Cell;
   friend class Node;
   friend class FigureEditor;
  public:
   Mesh(void) {
     // Make sure the reserved value is large enough if a cell is added
     // in "Divide" when the capacity is insufficient, "cells" might be
     // relocated including the current Cell (i.e. the value of *this)
     // calling "Mesh::IncreaseCapacityIfNecessary" (from another
     // object than Cell, e.g. Mesh) before entering Divide will solve
     // this issue (solved now).
     cells.reserve(2);
     nodes.reserve(500);
     time = 0.;
     plugin = 0;
   };
   ~Mesh(void) {
     delete boundary_polygon;
   };
   void Clean(void);
   Cell &EllipticCell(double xc, double yc, double ra, double rb, int nnodes=10, double rotation=0);
   Cell &CircularCell(double xc, double yc, double r, int nnodes=10) {
     return EllipticCell(xc, yc, r, r, nnodes, 0);
+  }
   Cell &LeafPrimordium(int n, double pet_length);
   Cell &LeafPrimordium2(int n);
   Cell *RectangularCell(const Vector ll, const Vector ur, double rotation = 0);
   void CellFiles(const Vector ll, const Vector ur);
   inline Cell &getCell(int i) {
     if ((unsigned)i<cells.size())
       return *cells[i];
     else {
 #ifdef QDEBUG
       qDebug() << i << endl;
       qDebug() << "size is " << cells.size() << endl;
 #endif
       abort();
+    }

src/miscq.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <QString>
 #include <QStringList>
 static const std::string _module_id("$Id$");
 // Returns the extension of a filename
 QString getExtension(const QString fn)
+{
   // split on dots
   QStringList parts = fn.split(".");
   // return last part, this should be the extension
   return QString(parts.last());
+}
 /* finis */

src/miscq.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _MISCQ_h_
 #define _MISCQ_h_
 #include <QString>
 // Miscellaneous helper functions, using Qt
 QString getExtension(const QString fn);
 #endif
 /* finis */

src/modelcatalogue.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include "modelcatalogue.h"
 #include <QVariant>
 static const std::string _module_id("$Id$");
 ModelCatalogue::ModelCatalogue(Mesh *_mesh, Main *_mainwin, const char *model=0) {
   mesh = _mesh;
   mainwin = _mainwin;
   if (model) {
     cerr << "Loading model: " << model << endl;
     LoadPlugin(model);
   } else {
     cerr << "Loading all models." << endl;
     LoadPlugins();
+  }
+}
 void ModelCatalogue::LoadPlugins() {
   QDir pluginDir(QApplication::applicationDirPath());
   QStringList plugin_filters; // filter for plugins, i.e "*.dll", "*.dylib"
 #if defined(Q_OS_WIN)
   if (pluginDir.dirName().toLower() =="debug"
       ||pluginDir.dirName().toLower() =="release")
     pluginDir.cdUp();
   plugin_filters << "*.dll";
 #elif defined(Q_OS_MAC)
   if (pluginDir.dirName() =="MacOS"){
     pluginDir.cdUp();
     pluginDir.cdUp();
     pluginDir.cdUp();
+  }
   plugin_filters << "*.dylib";
 #endif
   pluginDir.setNameFilters(plugin_filters);
   if (!pluginDir.cd("models")) {
     MyWarning::error("Directory 'models' not found!");
+  }
   //QVector<SimPluginInterface *> plugins;
   foreach (QString fileName, pluginDir.entryList(QDir::Files)){
     QPluginLoader loader(pluginDir.absoluteFilePath(fileName));
     if (SimPluginInterface *plugin =
 	qobject_cast<SimPluginInterface *>(loader.instance())) {
       models.append(plugin);
     } else {
       cerr << loader.errorString().toStdString().c_str() << endl;
       MyWarning::warning("Could not load model %s: %s",fileName.toStdString().c_str(), loader.errorString().toStdString().c_str());
+    }
+  }
   if (models.size()==0) {
     MyWarning::error("No models could be loaded.");
+  }
+}
 void ModelCatalogue::LoadPlugin(const char *model) {
   QDir pluginDir(QApplication::applicationDirPath());
   QStringList plugin_filters; // filter for plugins, i.e "*.dll", "*.dylib"
 #if defined(Q_OS_WIN)
   if (pluginDir.dirName().toLower() =="debug"
       ||pluginDir.dirName().toLower() =="release")
     pluginDir.cdUp();
   //plugin_filters << "*.dll";
 #elif defined(Q_OS_MAC)
   if (pluginDir.dirName() =="MacOS"){
     pluginDir.cdUp();
     pluginDir.cdUp();
     pluginDir.cdUp();
+  }
   //plugin_filters << "*.dylib";
 #endif
   plugin_filters << model;
   pluginDir.setNameFilters(plugin_filters);
   if (!pluginDir.cd("models")) {
     MyWarning::error("Directory 'models' not found!");
+  }

src/modelcatalogue.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _MODELCATALOGUE_H_
 #define _MODELCATALOGUE_H_
 #include "warning.h"
 #include "cell.h"
 #include "mesh.h"
 #include "simplugin.h"
 #include "canvas.h"
 #include <QPluginLoader>
 #include <Q3PopupMenu>
 #include <QAction>
 #include <QDir>
 #include <QApplication>
 #include <QObject>
 #include <QAction>
 #include <QMenu>
 class ModelCatalogue : public QObject {
   Q_OBJECT
     public:
   ModelCatalogue(Mesh *mesh, Main *mainwin, const char *model);
   void LoadPlugins();
   void LoadPlugin(const char *model);
   void InstallFirstModel();
   void PopulateModelMenu();
   public slots:
   void InstallModel(SimPluginInterface *model);
   void InstallModel(QAction *modelaction);
  private:
   QVector<SimPluginInterface *> models;
   Mesh *mesh;
   Main *mainwin;
 };
 #endif
 /* finis */

src/node.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <sstream>
 #ifdef QTGRAPHICS
 #include <qstring.h>
 #include <QGraphicsSimpleTextItem>
 #endif
 #include "node.h"
 #include "cell.h"
 #include "mesh.h"
 #include "random.h"
 #include "parameter.h"
 #include "sqr.h"
 #include "pi.h"
 #include "warning.h"
 static const std::string _module_id("$Id$");
 extern Parameter par;
 int Node::nnodes=0;
 double Node::target_length=1;
 ostream &Edge::print(ostream &os) const {
   return os << "{ " << first->Index() << ", " << second->Index() << " }";
+}
 ostream &Neighbor::print(ostream &os) const {
   os << " {" << cell->Index() << " " << nb1->Index() << " " << nb2->Index() << "}";
   return os;
+}
 ostream &operator<<(ostream &os, const Neighbor &n) {
   n.print(os);
   return os;
+}
 Node::Node(void) : Vector()
+{
   index=(nnodes++);
   node_set =0;
   fixed=false;
   boundary=false;
   sam=false;
   dead=false;
+}
 Node::Node(int ind) : Vector()
+{
   node_set =0;
   index=ind;
   fixed=false;
   boundary=false;
   sam=false;
   dead=false;
+}
 Node::Node(const Vector &src) : Vector(src)
+{
   node_set = 0;
   index=(nnodes++);
   fixed=false;
   boundary=false;
   sam=false;
   dead = false;
+}
 Node::Node(double x,double y, double z) : Vector (x,y,z)
+{
   node_set = 0;
   index=(nnodes++);
   fixed=false;
   boundary=false;
   sam=false;
   dead = false;
+}
 Node::Node(const Node &src) : Vector(src)
+{
   node_set=0;
   owners=src.owners;
   m=src.m;
   index=src.index;
   fixed = src.fixed;

src/node.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _NODE_H_
 #define _NODE_H_
 #include <list>
 //#include <pair>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #ifdef QTGRAPHICS
 #include <QGraphicsScene>
 #include <qcolor.h>
 #include <iostream>
 #endif
 #include "vector.h"
 #include "random.h"
 #include "parameter.h"
 #include "cell.h"
 #include "modelelement.h"
 #include <QVector>
 #include "Neighbor.h"
 extern Parameter par;
 class Edge {
  public:
   Edge(void) {
     first=0;
     second=0;
+  }
   Edge(Node *f, Node *s) {
     first=f;
     second=s;
+  }
   // Copy Constructor
   Edge(const Edge &src) {
     first=src.first;
     second=src.second;
+  }
   // Ambidextrous equivalence
   inline bool operator==(const Edge &e) {
     return ( (first==e.first && second==e.second) ||
 	     (first==e.second && second==e.first) );
+  }
   // Output the Edge
   ostream &print(ostream &os) const;
   Node *first, *second;
 };
 class NodeSet;
 // this class is a node in a cell wall
 class Node : public Vector {
   friend class Mesh;
   friend class CellBase;
   friend class Cell;
   friend class WallBase;
   friend class Wall;
   friend class NodeSet;
   friend class FigureEditor;
  public:
   Node(void);
   Node(int index); // if want to construct a node, and not increase nnodes
   Node(double x,double y, double z=0);
   Node(const Node &src);
   explicit Node(const Vector &src); // "nonconverting" - explicit constructor syntax required

src/nodeitem.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <QGraphicsScene>
 #include <QGraphicsItem>
 #include <QPainter>
 #include <QStyleOption>
 #include <Qt>
 #include "nodeitem.h"
 #include "parameter.h"
 static const std::string _module_id("$Id$");
 extern Parameter par;
 NodeItem::NodeItem( Node *n, QGraphicsScene *canvas )
   : QGraphicsItem( 0, canvas ), SimItemBase( n, canvas) {
   brush = Qt::darkGray;
   const double mag = par.node_mag;
   ellipsesize=QRectF(-1*mag, -1*mag, 2*mag, 2*mag);
+}
 void NodeItem::userMove(double dx, double dy)
+{
   QGraphicsItem::moveBy( dx, dy );
   class_cast<Node *>(obj)->x += (dx/Cell::Magnification());
   class_cast<Node *>(obj)->y += (dy/Cell::Magnification());
+}
 void NodeItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *)
+{
   painter->setBrush(brush);
   painter->setPen(Qt::NoPen);
   painter->drawEllipse(ellipsesize);
+}
 QPainterPath NodeItem::shape() const
+{
   QPainterPath path;
   path.addEllipse(ellipsesize);
   return path;
+}
 QRectF NodeItem::boundingRect() const
+{
   qreal penwidth = 0;// painter->pen()->widthF();
   return QRectF(ellipsesize.x()-penwidth/2.,ellipsesize.y()-penwidth/2.,
 		ellipsesize.width()+penwidth, ellipsesize.height()+penwidth);
+}
 // polymorphic OnClick functions
 void NodeItem::OnClick(void)
+{
   Node *n = &getNode();
   n->toggleBoundary();
   setColor();
   update();
+}
 void NodeItem::OnClick(const Qt::MouseButton &mb)
+{
   if (mb == Qt::LeftButton) {
     Node *n = &getNode();
     n->toggleBoundary();
     setColor();
     update();
+  }
+}
 void NodeItem::setColor(void)
+{
   static QColor indian_red("IndianRed");
   static QColor deep_sky_blue("DeepSkyBlue");
   static QColor purple("Purple");
   Node &n=getNode();
   if (n.SamP()) {
     setBrush( purple );
   } else {
     if (n.BoundaryP()) {

src/nodeitem.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _NODEITEM_H_
 #define _NODEITEM_H_
 #include <QGraphicsScene>
 #include <QGraphicsItem>
 #include "simitembase.h"
 #include "node.h"
 #include "cell.h"
 class NodeItem: public QGraphicsItem, public SimItemBase
+{
  public:
   NodeItem( Node *n, QGraphicsScene *canvas );
   ~NodeItem() {}
   Node &getNode(void) const { return *class_cast<Node*>(obj); }
   virtual void userMove(double dx, double dy);
   QRectF boundingRect() const;
   void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
   QPainterPath shape() const;
   void setBrush( QBrush newbrush) { brush = newbrush; }
   void setColor(void);
   /*! We use this function internally, to (somewhat) interactively edit init configurations.
     Simply put the property to be change upon clicking a node in this function. */
   void OnClick( const Qt::MouseButton &mb );
   void OnClick(void);
  protected:
   QBrush brush;
   QRectF ellipsesize;
  private:
 };
 #endif
 /* finis */

src/nodeset.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <ostream>
 #include "nodeset.h"
 static const std::string _module_id("$Id$");
 ostream &operator<<(ostream &os, const NodeSet &ns)  {
   ns.print(os);
   return os;
+}
 /* finis */

src/nodeset.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _NODESET_H_
 #define _NODESET_H_
 #include <algorithm>
 #include <numeric>
 #include <list>
 #include <iterator>
 #include "node.h"
 class NodeSet : public list<Node *> {
  public:
   NodeSet(void) {
     done = false;
+  }
   inline bool DoneP(void) { return done; }
   inline void ResetDone(void) { done = false; }
   void AddNode(Node * n) {
     push_back(n);
     n->node_set = this;
+  }
   list <Cell *> getCells(void) {
     list<Cell *> cellset;
     for (list<Node *>::const_iterator i=begin();
 	 i!=end();
 	 i++) {
       transform ( (*i)->owners.begin(), (*i)->owners.end(), back_inserter( cellset ) , mem_fun_ref ( &Neighbor::getCell ));
+    }
     cellset.sort();
     // remove all non-unique elements
     // (unique moves all unique elements to the front and returns an iterator to the end of the unique elements;
     // so we simply erase all remaining elements.
     cellset.erase(::unique(cellset.begin(), cellset.end() ), cellset.end() );
     // remove boundary_polygon
     cellset.erase( find_if ( cellset.begin(), cellset.end(), mem_fun( &Cell::BoundaryPolP  ) ) );
     return cellset;
+  }
   void CleanUp(void) {
     // remove double Nodes from the set
     sort();
     erase(::unique(begin(), end() ),
 	  end() );
+  }
   void print(ostream &os) const {
     transform( begin(), end(), ostream_iterator<int>( os, " " ), mem_fun( &Node::Index ) );
+  }
   /*! Attempt a move over (rx, ry)
     reject if energetically unfavourable.
   */
   void AttemptMove(double rx, double ry) {
     done = true;
     // 1. Collect list of all attached to the nodes in the set
     list<Cell *> celllist = getCells();
     // 2. Sum the current energy of these cells
     double old_energy=0.;
     double sum_stiff = 0.;
     for ( list<Cell *>::const_iterator i = celllist.begin();
 	  i!=celllist.end();
 	  ++i ) {
       old_energy += (*i)->Energy();
       sum_stiff += (*i)->Stiffness();
+    }
     // 3. (Temporarily) move the set's nodes.
     for ( list<Node *>::iterator n = begin();
 	  n!=end();
 	  ++n ) {

src/output.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include "warning.h"
 #include "parameter.h"
 #include "output.h"
 #include <QDir>
 #include <QFileInfo>
 static const std::string _module_id("$Id$");
 using namespace MyWarning;
 #define FNAMESIZE 100
 int OpenFileAndCheckExistance(FILE **fp,const char *fname,char *ftype) {
   *fp=fopen(fname,ftype);
   if (*fp==NULL)
     return FALSE;
   if (!strncmp(ftype,"a",1)) {
     if (ftell(*fp)>0L) return TRUE;
     else return FALSE;
   } else return TRUE;
+}
 int FileExistsP(const char *fname) {
   FILE *fp;
   fp=fopen(fname,"r");
   if (fp==NULL)
     return FALSE;
   fclose(fp);
   return TRUE;
+}
 int YesNoP(const char *message) {
   char answer[100];
   fprintf(stderr,"%s (y/n) ",message);
   fflush(stderr);
   scanf("%s",answer);
   while (strcmp(answer,"y") && strcmp(answer,"n")) {
     fprintf(stderr,"\n\bPlease answer 'y' or 'n'. ");
     fflush(stderr);
     scanf("%s",answer);
+  }
   if (!strcmp(answer,"y")) return TRUE;
   return FALSE;
+}
 FILE *OpenWriteFile(const char *filename)
+{
   char fname[FNAMESIZE];
   FILE *fp;
   fprintf(stderr,"Opening %s for writing\n",filename);
   if(FileExistsP(filename)==TRUE) {
     if (false/*par.interactive*/) {
       char *message=(char *)malloc(2000*sizeof(char));
       if (!YesNoP("File exists, overwrite?")) {
 	sprintf(message," Could not open file %s for writing, exiting... \n"
 		,filename);
 	//exit(0);
 	throw(message);
+      }
     } else {
       /* Rename old file */
       sprintf(fname, "%s~",filename);

src/output.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _OUTPUT_H_
 #define _OUTPUT_H_
 #ifdef __cplusplus
 extern "C" {
 #endif
   int OpenFileAndCheckExistance(FILE **fp,const char *fname,char *ftype);
   int YesNoP(const char *message);
   FILE *OpenWriteFile(const char *filename);
   FILE *OpenGZippedWriteFile(const char *filename);
   FILE *OpenReadFile(const char *filename);
   char *ReadLine(FILE *fp);
   void CheckFile(FILE *fp);
   int FileExistsP(const char *fname);
   char *Chext(char *filename);
   void MakeDir(const char *dirname);
   bool CanWeWriteP(char *filename);
 #ifdef __cplusplus
+}
 #endif
 #define MESS_BUF_SIZE 160
 #ifndef FALSE
 #define FALSE 0
 #define TRUE 1
 #endif
 #endif
 /* finis */

src/parameter.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include "parameter.h"
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <cerrno>
 #include <iostream>
 #include <sstream>
 #include "output.h"
 #include "parse.h"
 #include "xmlwrite.h"
 #include "warning.h"
 #include <QLocale>
 #include <QDir>
 #include <QStringList>
 using namespace std;
 static const std::string _module_id("$Id$");
 Parameter::Parameter() {
   arrowcolor = strdup("white");
   arrowsize = 100;
   textcolor = strdup("red");
   cellnumsize = 1;
   nodenumsize = 1;
   node_mag = 1.0;
   outlinewidth = 1.0;
   cell_outline_color = strdup("forestgreen");
   resize_stride = 0;
   T = 1.0;
   lambda_length = 100.;
   lambda_celllength = 0.;
   target_length = 60.;
   cell_expansion_rate = 1.;
   cell_div_expansion_rate = 0.;
   auxin_dependent_growth = true;
   ode_accuracy = 1e-4;
   mc_stepsize = 0.4;
   mc_cell_stepsize = 0.2;
   energy_threshold = 1000.;
   bend_lambda = 0.;
   alignment_lambda = 0.;
   rel_cell_div_threshold = 2.;
   rel_perimeter_stiffness = 2;
   collapse_node_threshold = 0.05;
   morphogen_div_threshold = 0.2;
   morphogen_expansion_threshold = 0.01;
   copy_wall = true;
   source = 0.;
   D = new double[15];
   D[0] = 0.;
   D[1] = 0.0;
   D[2] = 0.0;
   D[3] = 0.;
   D[4] = 0.;
   D[5] = 0.;
   D[6] = 0.;
   D[7] = 0.;
   D[8] = 0.;
   D[9] = 0.;
   D[10] = 0.;
   D[11] = 0.;
   D[12] = 0.;
   D[13] = 0.;
   D[14] = 0.;
   initval = new double[15];
   initval[0] = 0.;
   initval[1] = 0.;
   initval[2] = 0.;
   initval[3] = 0.;
   initval[4] = 0.;
   initval[5] = 0.;
   initval[6] = 0.;
   initval[7] = 0.;
   initval[8] = 0.;
   initval[9] = 0.;
   initval[10] = 0.;
   initval[11] = 0.;
   initval[12] = 0.;
   initval[13] = 0.;
   initval[14] = 0.;
   k1 = 1.;
   k2 = 0.3;
   r = 1.;
   kr = 1.;

src/parameter.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _PARAMETER_H_
 #define _PARAMETER_H_
 #include "vector.h"
 #include <vector>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 class Parameter {
  public:
   Parameter();
   ~Parameter();
   void CleanUp(void);
   void Read(const char *filename);
   void Write(ostream &os) const;
   void XMLAdd(xmlNode *root) const;
   void XMLRead(xmlNode *root);
   void AssignValToPar(const char *namec, const char *valc);
   void AssignValArrayToPar(const char *namec, vector<double> valarray);
   char * arrowcolor;
   double arrowsize;
   char * textcolor;
   int cellnumsize;
   int nodenumsize;
   double node_mag;
   double outlinewidth;
   char * cell_outline_color;
   int resize_stride;
   double T;
   double lambda_length;
   double lambda_celllength;
   double target_length;
   double cell_expansion_rate;
   double cell_div_expansion_rate;
   bool auxin_dependent_growth;
   double ode_accuracy;
   double mc_stepsize;
   double mc_cell_stepsize;
   double energy_threshold;
   double bend_lambda;
   double alignment_lambda;
   double rel_cell_div_threshold;
   double rel_perimeter_stiffness;
   double collapse_node_threshold;
   double morphogen_div_threshold;
   double morphogen_expansion_threshold;
   bool copy_wall;
   double source;
   double * D;
   double * initval;
   double k1;
   double k2;
   double r;
   double kr;
   double km;
   double Pi_tot;
   double transport;
   double ka;
   double pin_prod;
   double pin_prod_in_epidermis;
   double pin_breakdown;
   double pin_breakdown_internal;
   double aux1prod;
   double aux1prodmeso;
   double aux1decay;
   double aux1decaymeso;
   double aux1transport;
   double aux_cons;
   double aux_breakdown;
   double kaux1;
   double kap;
   double leaf_tip_source;
   double sam_efflux;
   double sam_auxin;
   double sam_auxin_breakdown;
   double van3prod;
   double van3autokat;
   double van3sat;
   double k2van3;
   double dt;
   double rd_dt;
   char * datadir;
   bool movie;
   int nit;

src/pardialog.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include "pardialog.h"
 #include "parameter.h"
 #include <cstring>
 #include <qdialog.h>
 #include <qlabel.h>
 #include <qlineedit.h>
 #include <qmessagebox.h>
 static const std::string _module_id("$Id$");
 ParameterDialog::ParameterDialog(QWidget *parent, const char *name, Qt::WindowFlags f) : QDialog(parent,name,false,f) {
   extern Parameter par;
   arrowcolor_edit = new QLineEdit( QString("%1").arg(par.arrowcolor), this, "arrowcolor_edit" );
   arrowsize_edit = new QLineEdit( QString("%1").arg(par.arrowsize), this, "arrowsize_edit" );
   textcolor_edit = new QLineEdit( QString("%1").arg(par.textcolor), this, "textcolor_edit" );
   cellnumsize_edit = new QLineEdit( QString("%1").arg(par.cellnumsize), this, "cellnumsize_edit" );
   nodenumsize_edit = new QLineEdit( QString("%1").arg(par.nodenumsize), this, "nodenumsize_edit" );
   node_mag_edit = new QLineEdit( QString("%1").arg(par.node_mag), this, "node_mag_edit" );
   outlinewidth_edit = new QLineEdit( QString("%1").arg(par.outlinewidth), this, "outlinewidth_edit" );
   cell_outline_color_edit = new QLineEdit( QString("%1").arg(par.cell_outline_color), this, "cell_outline_color_edit" );
   resize_stride_edit = new QLineEdit( QString("%1").arg(par.resize_stride), this, "resize_stride_edit" );
   T_edit = new QLineEdit( QString("%1").arg(par.T), this, "T_edit" );
   lambda_length_edit = new QLineEdit( QString("%1").arg(par.lambda_length), this, "lambda_length_edit" );
   lambda_celllength_edit = new QLineEdit( QString("%1").arg(par.lambda_celllength), this, "lambda_celllength_edit" );
   target_length_edit = new QLineEdit( QString("%1").arg(par.target_length), this, "target_length_edit" );
   cell_expansion_rate_edit = new QLineEdit( QString("%1").arg(par.cell_expansion_rate), this, "cell_expansion_rate_edit" );
   cell_div_expansion_rate_edit = new QLineEdit( QString("%1").arg(par.cell_div_expansion_rate), this, "cell_div_expansion_rate_edit" );
   auxin_dependent_growth_edit = new QLineEdit( QString("%1").arg(sbool(par.auxin_dependent_growth)), this, "auxin_dependent_growth_edit" );
   ode_accuracy_edit = new QLineEdit( QString("%1").arg(par.ode_accuracy), this, "ode_accuracy_edit" );
   mc_stepsize_edit = new QLineEdit( QString("%1").arg(par.mc_stepsize), this, "mc_stepsize_edit" );
   mc_cell_stepsize_edit = new QLineEdit( QString("%1").arg(par.mc_cell_stepsize), this, "mc_cell_stepsize_edit" );
   energy_threshold_edit = new QLineEdit( QString("%1").arg(par.energy_threshold), this, "energy_threshold_edit" );
   bend_lambda_edit = new QLineEdit( QString("%1").arg(par.bend_lambda), this, "bend_lambda_edit" );
   alignment_lambda_edit = new QLineEdit( QString("%1").arg(par.alignment_lambda), this, "alignment_lambda_edit" );
   rel_cell_div_threshold_edit = new QLineEdit( QString("%1").arg(par.rel_cell_div_threshold), this, "rel_cell_div_threshold_edit" );
   rel_perimeter_stiffness_edit = new QLineEdit( QString("%1").arg(par.rel_perimeter_stiffness), this, "rel_perimeter_stiffness_edit" );
   collapse_node_threshold_edit = new QLineEdit( QString("%1").arg(par.collapse_node_threshold), this, "collapse_node_threshold_edit" );
   morphogen_div_threshold_edit = new QLineEdit( QString("%1").arg(par.morphogen_div_threshold), this, "morphogen_div_threshold_edit" );
   morphogen_expansion_threshold_edit = new QLineEdit( QString("%1").arg(par.morphogen_expansion_threshold), this, "morphogen_expansion_threshold_edit" );
   copy_wall_edit = new QLineEdit( QString("%1").arg(sbool(par.copy_wall)), this, "copy_wall_edit" );
   source_edit = new QLineEdit( QString("%1").arg(par.source), this, "source_edit" );
   QString D_string("%1,%2,%3,%4,%5,%6,%7,%8,%9,%10,%11,%12,%13,%14,%15");
   D_string = D_string.arg(par.D[0]).arg(par.D[1]).arg(par.D[2]).arg(par.D[3]).arg(par.D[4]).arg(par.D[5]).arg(par.D[6]).arg(par.D[7]).arg(par.D[8]).arg(par.D[9]).arg(par.D[10]).arg(par.D[11]).arg(par.D[12]).arg(par.D[13]).arg(par.D[14]);
   D_edit = new QLineEdit( D_string, this, "D_edit" );
   QString initval_string("%1,%2,%3,%4,%5,%6,%7,%8,%9,%10,%11,%12,%13,%14,%15");
   initval_string = initval_string.arg(par.initval[0]).arg(par.initval[1]).arg(par.initval[2]).arg(par.initval[3]).arg(par.initval[4]).arg(par.initval[5]).arg(par.initval[6]).arg(par.initval[7]).arg(par.initval[8]).arg(par.initval[9]).arg(par.initval[10]).arg(par.initval[11]).arg(par.initval[12]).arg(par.initval[13]).arg(par.initval[14]);
   initval_edit = new QLineEdit( initval_string, this, "initval_edit" );
   k1_edit = new QLineEdit( QString("%1").arg(par.k1), this, "k1_edit" );
   k2_edit = new QLineEdit( QString("%1").arg(par.k2), this, "k2_edit" );
   r_edit = new QLineEdit( QString("%1").arg(par.r), this, "r_edit" );
   kr_edit = new QLineEdit( QString("%1").arg(par.kr), this, "kr_edit" );
   km_edit = new QLineEdit( QString("%1").arg(par.km), this, "km_edit" );
   Pi_tot_edit = new QLineEdit( QString("%1").arg(par.Pi_tot), this, "Pi_tot_edit" );
   transport_edit = new QLineEdit( QString("%1").arg(par.transport), this, "transport_edit" );
   ka_edit = new QLineEdit( QString("%1").arg(par.ka), this, "ka_edit" );
   pin_prod_edit = new QLineEdit( QString("%1").arg(par.pin_prod), this, "pin_prod_edit" );
   pin_prod_in_epidermis_edit = new QLineEdit( QString("%1").arg(par.pin_prod_in_epidermis), this, "pin_prod_in_epidermis_edit" );
   pin_breakdown_edit = new QLineEdit( QString("%1").arg(par.pin_breakdown), this, "pin_breakdown_edit" );
   pin_breakdown_internal_edit = new QLineEdit( QString("%1").arg(par.pin_breakdown_internal), this, "pin_breakdown_internal_edit" );
   aux1prod_edit = new QLineEdit( QString("%1").arg(par.aux1prod), this, "aux1prod_edit" );
   aux1prodmeso_edit = new QLineEdit( QString("%1").arg(par.aux1prodmeso), this, "aux1prodmeso_edit" );
   aux1decay_edit = new QLineEdit( QString("%1").arg(par.aux1decay), this, "aux1decay_edit" );
   aux1decaymeso_edit = new QLineEdit( QString("%1").arg(par.aux1decaymeso), this, "aux1decaymeso_edit" );
   aux1transport_edit = new QLineEdit( QString("%1").arg(par.aux1transport), this, "aux1transport_edit" );
   aux_cons_edit = new QLineEdit( QString("%1").arg(par.aux_cons), this, "aux_cons_edit" );
   aux_breakdown_edit = new QLineEdit( QString("%1").arg(par.aux_breakdown), this, "aux_breakdown_edit" );
   kaux1_edit = new QLineEdit( QString("%1").arg(par.kaux1), this, "kaux1_edit" );
   kap_edit = new QLineEdit( QString("%1").arg(par.kap), this, "kap_edit" );
   leaf_tip_source_edit = new QLineEdit( QString("%1").arg(par.leaf_tip_source), this, "leaf_tip_source_edit" );
   sam_efflux_edit = new QLineEdit( QString("%1").arg(par.sam_efflux), this, "sam_efflux_edit" );
   sam_auxin_edit = new QLineEdit( QString("%1").arg(par.sam_auxin), this, "sam_auxin_edit" );
   sam_auxin_breakdown_edit = new QLineEdit( QString("%1").arg(par.sam_auxin_breakdown), this, "sam_auxin_breakdown_edit" );
   van3prod_edit = new QLineEdit( QString("%1").arg(par.van3prod), this, "van3prod_edit" );
   van3autokat_edit = new QLineEdit( QString("%1").arg(par.van3autokat), this, "van3autokat_edit" );
   van3sat_edit = new QLineEdit( QString("%1").arg(par.van3sat), this, "van3sat_edit" );
   k2van3_edit = new QLineEdit( QString("%1").arg(par.k2van3), this, "k2van3_edit" );
   dt_edit = new QLineEdit( QString("%1").arg(par.dt), this, "dt_edit" );
   rd_dt_edit = new QLineEdit( QString("%1").arg(par.rd_dt), this, "rd_dt_edit" );
   datadir_edit = new QLineEdit( QString("%1").arg(par.datadir), this, "datadir_edit" );
   movie_edit = new QLineEdit( QString("%1").arg(sbool(par.movie)), this, "movie_edit" );
   nit_edit = new QLineEdit( QString("%1").arg(par.nit), this, "nit_edit" );
   maxt_edit = new QLineEdit( QString("%1").arg(par.maxt), this, "maxt_edit" );
   storage_stride_edit = new QLineEdit( QString("%1").arg(par.storage_stride), this, "storage_stride_edit" );
   xml_storage_stride_edit = new QLineEdit( QString("%1").arg(par.xml_storage_stride), this, "xml_storage_stride_edit" );
   rseed_edit = new QLineEdit( QString("%1").arg(par.rseed), this, "rseed_edit" );
   constituous_expansion_limit_edit = new QLineEdit( QString("%1").arg(par.constituous_expansion_limit), this, "constituous_expansion_limit_edit" );
   vessel_inh_level_edit = new QLineEdit( QString("%1").arg(par.vessel_inh_level), this, "vessel_inh_level_edit" );
   vessel_expansion_rate_edit = new QLineEdit( QString("%1").arg(par.vessel_expansion_rate), this, "vessel_expansion_rate_edit" );
   d_edit = new QLineEdit( QString("%1").arg(par.d), this, "d_edit" );
   e_edit = new QLineEdit( QString("%1").arg(par.e), this, "e_edit" );
   f_edit = new QLineEdit( QString("%1").arg(par.f), this, "f_edit" );
   c_edit = new QLineEdit( QString("%1").arg(par.c), this, "c_edit" );
   mu_edit = new QLineEdit( QString("%1").arg(par.mu), this, "mu_edit" );
   nu_edit = new QLineEdit( QString("%1").arg(par.nu), this, "nu_edit" );
   rho0_edit = new QLineEdit( QString("%1").arg(par.rho0), this, "rho0_edit" );
   rho1_edit = new QLineEdit( QString("%1").arg(par.rho1), this, "rho1_edit" );
   c0_edit = new QLineEdit( QString("%1").arg(par.c0), this, "c0_edit" );
   gamma_edit = new QLineEdit( QString("%1").arg(par.gamma), this, "gamma_edit" );
   eps_edit = new QLineEdit( QString("%1").arg(par.eps), this, "eps_edit" );
   QString k_string("%1,%2,%3,%4,%5,%6,%7,%8,%9,%10,%11,%12,%13,%14,%15");
   k_string = k_string.arg(par.k[0]).arg(par.k[1]).arg(par.k[2]).arg(par.k[3]).arg(par.k[4]).arg(par.k[5]).arg(par.k[6]).arg(par.k[7]).arg(par.k[8]).arg(par.k[9]).arg(par.k[10]).arg(par.k[11]).arg(par.k[12]).arg(par.k[13]).arg(par.k[14]);
   k_edit = new QLineEdit( k_string, this, "k_edit" );
   i1_edit = new QLineEdit( QString("%1").arg(par.i1), this, "i1_edit" );
   i2_edit = new QLineEdit( QString("%1").arg(par.i2), this, "i2_edit" );
   i3_edit = new QLineEdit( QString("%1").arg(par.i3), this, "i3_edit" );
   i4_edit = new QLineEdit( QString("%1").arg(par.i4), this, "i4_edit" );
   i5_edit = new QLineEdit( QString("%1").arg(par.i5), this, "i5_edit" );
   s1_edit = new QLineEdit( QString("%1").arg(par.s1), this, "s1_edit" );
   s2_edit = new QLineEdit( QString("%1").arg(par.s2), this, "s2_edit" );
   s3_edit = new QLineEdit( QString("%1").arg(par.s3), this, "s3_edit" );
   b1_edit = new QLineEdit( QString("%1").arg(sbool(par.b1)), this, "b1_edit" );
   b2_edit = new QLineEdit( QString("%1").arg(sbool(par.b2)), this, "b2_edit" );
   b3_edit = new QLineEdit( QString("%1").arg(sbool(par.b3)), this, "b3_edit" );
   b4_edit = new QLineEdit( QString("%1").arg(sbool(par.b4)), this, "b4_edit" );
   dir1_edit = new QLineEdit( QString("%1").arg(par.dir1), this, "dir1_edit" );
   dir2_edit = new QLineEdit( QString("%1").arg(par.dir2), this, "dir2_edit" );
   // make a 1x1 grid; it will auto-expand
   QGridLayout *grid = new QGridLayout( this, 1, 1 );
   // add the first four widgets with (row, column) addressing
   setWindowTitle( QString( " Parameter values for The Virtual Leaf") );
   grid->addWidget( new QLabel( "<h3> Parameter values for The Virtual Leaf</h3>",this), 0, 0, 1, -1, Qt::AlignCenter);
   setWindowTitle( QString( " Parameter values for VirtualLeaf") );
   grid->addWidget( new QLabel( "<h3> Parameter values for VirtualLeaf</h3>",this), 0, 0, 1, -1, Qt::AlignCenter);
   grid->addWidget( new QLabel( "", this), 0+1, 0, 1, -1);
   grid->addWidget( new QLabel( " <b>Visualization</b>", this), 3, 0, 1, 2 );
   grid->addWidget( new QLabel( "arrowcolor", this ),4, 0 );
   grid->addWidget( arrowcolor_edit, 4, 0+1  );
   grid->addWidget( new QLabel( "arrowsize", this ),5, 0 );
   grid->addWidget( arrowsize_edit, 5, 0+1  );
   grid->addWidget( new QLabel( "textcolor", this ),6, 0 );
   grid->addWidget( textcolor_edit, 6, 0+1  );
   grid->addWidget( new QLabel( "cellnumsize", this ),7, 0 );
   grid->addWidget( cellnumsize_edit, 7, 0+1  );
   grid->addWidget( new QLabel( "nodenumsize", this ),8, 0 );
   grid->addWidget( nodenumsize_edit, 8, 0+1  );
   grid->addWidget( new QLabel( "node_mag", this ),9, 0 );
   grid->addWidget( node_mag_edit, 9, 0+1  );
   grid->addWidget( new QLabel( "outlinewidth", this ),10, 0 );
   grid->addWidget( outlinewidth_edit, 10, 0+1  );
   grid->addWidget( new QLabel( "cell_outline_color", this ),11, 0 );
   grid->addWidget( cell_outline_color_edit, 11, 0+1  );
   grid->addWidget( new QLabel( "resize_stride", this ),12, 0 );
   grid->addWidget( resize_stride_edit, 12, 0+1  );
   grid->addWidget( new QLabel( "", this), 13, 0, 1, 2 );
   grid->addWidget( new QLabel( " <b>Cell mechanics</b>", this), 14, 0, 1, 2 );
   grid->addWidget( new QLabel( "T", this ),15, 0 );
   grid->addWidget( T_edit, 15, 0+1  );
   grid->addWidget( new QLabel( "lambda_length", this ),16, 0 );
   grid->addWidget( lambda_length_edit, 16, 0+1  );
   grid->addWidget( new QLabel( "lambda_celllength", this ),17, 0 );
   grid->addWidget( lambda_celllength_edit, 17, 0+1  );
   grid->addWidget( new QLabel( "target_length", this ),18, 0 );
   grid->addWidget( target_length_edit, 18, 0+1  );
   grid->addWidget( new QLabel( "cell_expansion_rate", this ),19, 0 );
   grid->addWidget( cell_expansion_rate_edit, 19, 0+1  );
   grid->addWidget( new QLabel( "cell_div_expansion_rate", this ),20, 0 );
   grid->addWidget( cell_div_expansion_rate_edit, 20, 0+1  );
   grid->addWidget( new QLabel( "auxin_dependent_growth", this ),21, 0 );
   grid->addWidget( auxin_dependent_growth_edit, 21, 0+1  );
   grid->addWidget( new QLabel( "ode_accuracy", this ),22, 0 );
   grid->addWidget( ode_accuracy_edit, 22, 0+1  );
   grid->addWidget( new QLabel( "mc_stepsize", this ),23, 0 );
   grid->addWidget( mc_stepsize_edit, 23, 0+1  );
   grid->addWidget( new QLabel( "mc_cell_stepsize", this ),24, 0 );
   grid->addWidget( mc_cell_stepsize_edit, 24, 0+1  );
   grid->addWidget( new QLabel( "energy_threshold", this ),25, 0 );
   grid->addWidget( energy_threshold_edit, 25, 0+1  );
   grid->addWidget( new QLabel( "bend_lambda", this ),26, 0 );
   grid->addWidget( bend_lambda_edit, 26, 0+1  );
   grid->addWidget( new QLabel( "alignment_lambda", this ),27, 0 );
   grid->addWidget( alignment_lambda_edit, 27, 0+1  );
   grid->addWidget( new QLabel( "rel_cell_div_threshold", this ),28, 0 );
   grid->addWidget( rel_cell_div_threshold_edit, 28, 0+1  );
   grid->addWidget( new QLabel( "rel_perimeter_stiffness", this ),29, 0 );
   grid->addWidget( rel_perimeter_stiffness_edit, 29, 0+1  );
   grid->addWidget( new QLabel( "collapse_node_threshold", this ),3, 2 );
   grid->addWidget( collapse_node_threshold_edit, 3, 2+1  );
   grid->addWidget( new QLabel( "morphogen_div_threshold", this ),4, 2 );
   grid->addWidget( morphogen_div_threshold_edit, 4, 2+1  );
   grid->addWidget( new QLabel( "morphogen_expansion_threshold", this ),5, 2 );
   grid->addWidget( morphogen_expansion_threshold_edit, 5, 2+1  );
   grid->addWidget( new QLabel( "copy_wall", this ),6, 2 );
   grid->addWidget( copy_wall_edit, 6, 2+1  );
   grid->addWidget( new QLabel( "", this), 7, 2, 1, 2 );
   grid->addWidget( new QLabel( " <b>Auxin transport and PIN1 dynamics</b>", this), 8, 2, 1, 2 );
   grid->addWidget( new QLabel( "source", this ),9, 2 );
   grid->addWidget( source_edit, 9, 2+1  );
   grid->addWidget( new QLabel( "D", this ),10, 2 );
   grid->addWidget( D_edit, 10, 2+1  );
   grid->addWidget( new QLabel( "initval", this ),11, 2 );
   grid->addWidget( initval_edit, 11, 2+1  );
   grid->addWidget( new QLabel( "k1", this ),12, 2 );
   grid->addWidget( k1_edit, 12, 2+1  );
   grid->addWidget( new QLabel( "k2", this ),13, 2 );
   grid->addWidget( k2_edit, 13, 2+1  );
   grid->addWidget( new QLabel( "r", this ),14, 2 );
   grid->addWidget( r_edit, 14, 2+1  );
   grid->addWidget( new QLabel( "kr", this ),15, 2 );
   grid->addWidget( kr_edit, 15, 2+1  );
   grid->addWidget( new QLabel( "km", this ),16, 2 );
   grid->addWidget( km_edit, 16, 2+1  );
   grid->addWidget( new QLabel( "Pi_tot", this ),17, 2 );
   grid->addWidget( Pi_tot_edit, 17, 2+1  );
   grid->addWidget( new QLabel( "transport", this ),18, 2 );
   grid->addWidget( transport_edit, 18, 2+1  );
   grid->addWidget( new QLabel( "ka", this ),19, 2 );
   grid->addWidget( ka_edit, 19, 2+1  );
   grid->addWidget( new QLabel( "pin_prod", this ),20, 2 );
   grid->addWidget( pin_prod_edit, 20, 2+1  );
   grid->addWidget( new QLabel( "pin_prod_in_epidermis", this ),21, 2 );
   grid->addWidget( pin_prod_in_epidermis_edit, 21, 2+1  );
   grid->addWidget( new QLabel( "pin_breakdown", this ),22, 2 );
   grid->addWidget( pin_breakdown_edit, 22, 2+1  );
   grid->addWidget( new QLabel( "pin_breakdown_internal", this ),23, 2 );
   grid->addWidget( pin_breakdown_internal_edit, 23, 2+1  );
   grid->addWidget( new QLabel( "aux1prod", this ),24, 2 );
   grid->addWidget( aux1prod_edit, 24, 2+1  );
   grid->addWidget( new QLabel( "aux1prodmeso", this ),25, 2 );
   grid->addWidget( aux1prodmeso_edit, 25, 2+1  );

src/parse.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include "warning.h"
 #include "parse.h"
 #include "output.h"
 #include <string>
 static const std::string _module_id("$Id$");
 using namespace MyWarning;
 char *ParsePar(FILE *fp, char *parameter, bool wrapflag)
+{
   char *line,*token;
   char *value;
   line=SearchToken(fp,parameter, wrapflag);
   if (line==NULL) {
     warning("Warning: Token %s not found.",parameter);
     value=0;
     return value;
+  }
   /* parse the line on = sign */
   token=strtok(line,"=");
   if (token==NULL) {
     error("Parse error: no '=' sign found next to token %s, in line: \n %s.",
 	  parameter,line);
+  }
   // warning("Reading value for token %s...",token);
   fprintf(stderr, "[%s = ",token);
   token=strtok(NULL,"=");
   if (token==NULL)
     error("\nParse error: no value found after '=' sign, in line: \n %s",
 	  line);
   value=strdup(token);
   free(line);
   return value;
+}
 int igetpar(FILE *fp,char *parameter, bool wrapflag) {
   // overloaded compatibility function. Doesn't need default parameter
   return igetpar(fp, parameter, 0, wrapflag);
+}
 int igetpar(FILE *fp,char *parameter, int default_val, bool wrapflag)
+{
   char *token;
   int value;
   /* Get token representing the value */
   token=ParsePar(fp,parameter, wrapflag);
   if (token==0) {
     /* default value */
     warning("No token %s found. Using default value %d.\n", parameter, default_val);
     return default_val;
+  }
   /* read it */
   sscanf(token,"%d",&value);
   fprintf(stderr, "%d]\n",value);
   free(token);
   return value;
+}
 float fgetpar(FILE *fp,char *parameter, bool wrapflag) {
   // overloaded compatibility function. Doesn't need default parameter
   return fgetpar(fp, parameter, 0., wrapflag);
+}
 float fgetpar(FILE *fp, char *parameter, double default_val, bool wrapflag)
+{

src/parse.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _PARSE_H_
 #define _PARSE_H_
 char *ParsePar(FILE *fp, char *parameter, bool wrapflag);
 int igetpar(FILE *fp,char *parameter, bool wrapflag);
 int igetpar(FILE *fp,char *parameter, int default_val, bool wrapflag);
 float fgetpar(FILE *fp,char *parameter, bool wrapflag);
 float fgetpar(FILE *fp,char *parameter, double default_val, bool wrapflag);
 /* Get a list of n comma separated doubles */
 double *dgetparlist(FILE *fp,char *parameter, int n, bool wrapflag);
 char *sgetpar(FILE *fp,char *parameter, bool wrapflag);
 char *sgetpar(FILE *fp,char *parameter,const char *default_val, bool wrapflag);
 bool bgetpar(FILE *fp, char *parameter, bool wrapflag);
 bool bgetpar(FILE *fp, char *parameter, int default_val, bool wrapflag);
 char *SearchToken(FILE *fp, char *token, bool wrapflag);
 int TokenInLineP(char *line,char *token);
 void SkipToken(FILE *fp,char *token, bool wrapflag);
 void SkipLine(FILE *fp);
 char *bool_str(bool bool_var);
 #endif
 /* finis */

src/pi.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _PI_H_
 #define _PI_H_
 const double Pi=3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170676;
 #endif
 /* finis */

src/qcanvasarrow.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _QCANVASARROW_H_
 #define _QCANVASARROW_H_
 #include <QGraphicsScene>
 class QGraphicsArrowItem : public QGraphicsLineItem {
  public:
  QGraphicsArrowItem(QGraphicsItem *parent, QGraphicsScene *c) : QGraphicsLineItem(parent, c) {};
   void paint ( QPainter *p, const QStyleOptionGraphicsItem *option,
 	       QWidget *widget ) {
     // construct arrow head
     QPointF start=line().p1();
     QPointF end=line().p2();
     QPointF mid=start + (3./4.)*(end-start);
     double vx=end.x()-start.x();
     double vy=end.y()-start.y();
     double length = sqrt(vx*vx+vy*vy);
     if (length==0) return;
     // perpendicular vector
     double px=-vy/length;
     double py=vx/length;
     // Arrow head lines go from end point
     // to points about 3/4 of the total arrow, extending sideways about 1/4
     // of the arrow length.
     QPointF arwp1 = mid + QPointF( (int)( (length/4.)*px ),
 				   (int)( (length/4.)*py ) );
     QPointF arwp2 = mid - QPointF( (int)( (length/4.)*px ),
 				   (int)( (length/4.)*py ) );
     p->setPen(pen());
     // Draw arrow head
     p->drawLine( end, arwp1 );
     p->drawLine( end, arwp2 );
     // Draw arrow line
     p->drawLine( start, end);
+  }
 };
 #endif
 /* finis */

src/random.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <QDebug>
 #include <string>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/timeb.h>
 #include <iostream>
 #include "random.h"
 static const std::string _module_id("$Id$");
 static int idum = -1;
 using namespace std;
 static int counter=0;
 /*! \return A random double between 0 and 1
 **/
 double RANDOM(void)
 /* Knuth's substrative method, see Numerical Recipes */
+{
   static int inext,inextp;
   static long ma[56];
   static int iff=0;
   counter++;
   long mj,mk;
   int i,ii,k;
   if (idum < 0 || iff == 0) {
     iff=1;
     mj=MSEED-(idum < 0 ? -idum : idum);
     mj %= MBIG;
     ma[55]=mj;
     mk=1;
     i=1;
     do {
       ii=(21*i) % 55;
       ma[ii]=mk;
       mk=mj-mk;
       if (mk < MZ) mk += MBIG;
       mj=ma[ii];
     } while ( ++i <= 54 );
     k=1;
     do {
       i=1;
       do {
         ma[i] -= ma[1+(i+30) % 55];
         if (ma[i] < MZ) ma[i] += MBIG;
       } while ( ++i <= 55 );
     } while ( ++k <= 4 );
     inext=0;
     inextp=31;
     idum=1;
+  }
   if (++inext == 56) inext=1;
   if (++inextp == 56) inextp=1;
   mj=ma[inext]-ma[inextp];
   if (mj < MZ) mj += MBIG;
   ma[inext]=mj;
   return mj*FAC;
+}
 /*! \param An integer random seed
   \return the random seed
 **/
 int Seed(int seed)
+{
   if (seed < 0) {
     int rseed=Randomize();
 #ifdef QDEBUG
     qDebug() << "Randomizing random generator, seed is " << rseed << endl;
 #endif
     return rseed;
   } else {
     int i;
     idum = -seed;
     for (i=0; i <100; i++)
       RANDOM();
     return seed;
+  }
+}
 /*! Returns a random integer value between 1 and 'max'
   \param The maximum value (long)
   \return A random integer (long)
 **/

src/random.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _RANDOM_H_
 #define _RANDOM_H_
 #define MBIG 1000000000
 #define MSEED 161803398
 #define MZ 0
 #define FAC (1.0/MBIG)
 double RANDOM();
 int Seed(int seed);
 long RandomNumber(long max);
 void AskSeed();
 int Randomize(void);
 int RandomCounter(void);
 // Class MyUrand, so we can pass the random generator to STL's random_shuffle,
 // and get identical simulations for a given random seed.
 class MyUrand {
   long n;
  public:
   MyUrand(long nn) {
     n=nn;
+  }
   MyUrand(void){};
   void seed(long s) {
     Seed(s);
+  }
   long operator()(long nn) { return RandomNumber(nn)-1; }
   long operator()(void) { return RandomNumber(n); }
 };
 #endif
 /* finis */

src/rungekutta.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <math.h>
 #include <iostream>
 #include "rungekutta.h"
 #include "warning.h"
 #include "maxmin.h"
 static const std::string _module_id("$Id$");
 // The value Errcon equals (5/Safety) raised to the power (1/PGrow), see use below.
 /*
   static float maxarg1,maxarg2;
   #define FMAX(a,b) (maxarg1=(a),maxarg2=(b),(maxarg1) > (maxarg2) ?\
   (maxarg1) : (maxarg2))
   static float minarg1,minarg2;
   #define FMIN(a,b) (minarg1=(a),minarg2=(b),(minarg1) < (minarg2) ?\
   (minarg1) : (minarg2))
   #define SIGN(a,b) ((b) >= 0.0 ? fabs(a) : -fabs(a))
 */
 const double RungeKutta::Safety  = 0.9;
 const double RungeKutta::PGrow = -0.2;
 const double RungeKutta::Pshrnk = -0.25;
 const double RungeKutta::Errcon = 1.89e-4;
 const double RungeKutta::Maxstp = 10000;
 const double RungeKutta::Tiny = 1.0e-30;
 void RungeKutta::rkqs(double *y, double *dydx, int n, double *x, double htry, double eps,
 		      double *yscal, double *hdid, double *hnext)
 /* Fifth-order Runge-Kutta step with monitoring of local truncation error to ensure accuracy and
    adjust stepsize. Input are the dependent variable vector y[1..n] and its derivative dydx[1..n]
    at the starting value of the independent variable x. Also input are the stepsize to be attempted
    htry, the required accuracy eps, and the vector yscal[1..n] against which the error is
    scaled. On output, y and x are replaced by their new values, hdid is the stepsize that was
    actuallyac complished, and hnext is the estimated next stepsize. derivs is the user-supplied
    routine that computes the right-hand side derivatives. */
+{
   int i;
   double errmax,h,htemp,xnew,*yerr,*ytemp;
   yerr=new double[n];
   ytemp=new double[n];
   h=htry; // Set stepsize to the initial trial value.
   for (;;) {
     rkck(y,dydx,n,*x,h,ytemp,yerr); // Take a step.
     errmax=0.0; //Evaluate accuracy.
     for (i=0;i<n;i++) errmax=FMAX(errmax,fabs(yerr[i]/yscal[i]));
     errmax /= eps; // Scale relative to required tolerance.
     if (errmax <= 1.0) break; //Step succeeded. Compute size of next step.
     htemp=Safety*h*pow(errmax,Pshrnk);
     //Truncation error too large, reduce stepsize.
     h=(h >= 0.0 ? FMAX(htemp,0.1*h) : FMIN(htemp,0.1*h));
     //No more than a factor of 10.
     xnew=(*x)+h;
     if (xnew == *x) MyWarning::error("stepsize underflow in rkqs, with h = %f and htry = %f",h, htry);
+  }
   if (errmax > Errcon) {
     *hnext=Safety*h*pow(errmax,PGrow);
     //std::cerr << "hnext = " << *hnext << std::endl;
+  }
   else *hnext=5.0*h; //No more than a factor of 5 increase.
   *x += (*hdid=h);
   for (i=0;i<n;i++) y[i]=ytemp[i];
   delete[] ytemp;
   delete[] yerr;
+}
 void RungeKutta::rkck(double *y, double *dydx, int n, double x, double h, double *yout, double *yerr)
 /*Given values for n variables y[1..n] and their derivatives dydx[1..n] known at x, use
   the fifth-order Cash-Karp Runge-Kutta method to advance the solution over an interval h
   and return the incremented variables as yout[1..n]. Also return an estimate of the local
   truncation error in yout using the embedded fourth-order method. The user supplies the routine
   derivs(x,y,dydx), which returns derivatives dydx at x.*/
+{
   int i;
   static double a2=0.2,a3=0.3,a4=0.6,a5=1.0,a6=0.875,b21=0.2,
     b31=3.0/40.0,b32=9.0/40.0,b41=0.3,b42 = -0.9,b43=1.2,
     b51 = -11.0/54.0, b52=2.5,b53 = -70.0/27.0,b54=35.0/27.0,
     b61=1631.0/55296.0,b62=175.0/512.0,b63=575.0/13824.0,
     b64=44275.0/110592.0,b65=253.0/4096.0,c1=37.0/378.0,
     c3=250.0/621.0,c4=125.0/594.0,c6=512.0/1771.0,
     dc5 = -277.00/14336.0;

src/rungekutta.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _RUNGEKUTTA_H_
 #define _RUNGEKUTTA_H_
 class RungeKutta  {
  public:
   RungeKutta(void) {
     kmax=kount=0;
     dxsav=0.;
     xp=0;
     yp=0;
+  }
   virtual ~RungeKutta() {}
   void odeint(double ystart[], int nvar, double x1, double x2, double eps, double h1,
 	      double hmin, int *nok, int *nbad);
  protected:
   // implement "derivs" in a derived class
   virtual void derivs(double x, double *y, double *dxdy) = 0;
   int kmax,kount;
   double *xp,**yp,dxsav;
  private:
   void rkqs(double *y, double *dydx, int n, double *x, double htry, double eps,
 	    double *yscal, double *hdid, double *hnext);
   void rkck(double *y, double *dydx, int n, double x, double h, double yout[],
 	    double *yerr);
   static const double Safety;
   static const double PGrow;
   static const double Pshrnk;
   static const double Errcon;
   static const double Maxstp;
   static const double Tiny;
 };
 #endif
 /* finis */

src/simitembase.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <QBrush>
 #include "simitembase.h"
 static const std::string _module_id("$Id$");
 SimItemBase::SimItemBase( void *v, QGraphicsScene *canvas )
+{
   obj=v;
 };
 SimItemBase::~SimItemBase(void) {};
 void SimItemBase::userMove(double dx, double dy){};
 /* finis */

src/simitembase.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _SIMITEMBASE_H_
 #define _SIMITEMBASE_H_
 #include <QGraphicsScene>
 #include <QBrush>
 #include <assert.h>
 class Vector;
 template<class TYPE>
 TYPE class_cast(void * symbol)
+{
   assert(sizeof(void *) == sizeof(TYPE));
   union
+  {
     void * symbol;
     TYPE unknownclass;
   } cast;
   cast.symbol = symbol;
   return cast.unknownclass;
+}
 class SimItemBase
+{
  public:
   SimItemBase( void *v, QGraphicsScene *canvas );
   virtual ~SimItemBase(void);
   virtual void userMove(double dx, double dy);
  protected:
   // I know which simulation object I represent, so if I am moved around
   // the canvas, the real object can be moved as well
   // (both Cell and Node have Vector as base class...)
   // Not proper design... sorry.
   void *obj;
 };
 #endif
 /* finis */

src/simplugin.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _SIMPLUGIN_H_
 #define _SIMPLUGIN_H_
 #include <QtPlugin>
 #include <QMetaType>
 #include "cellbase.h"
 #include "wallbase.h"
 class Parameter;
 #include <QColor>
 #include <QString>
 class SimPluginInterface {
  public:
   virtual QString ModelID(void) = 0;
   virtual ~SimPluginInterface() { }
   // Executed after the cellular mechanics steps have equillibrized
   virtual void CellHouseKeeping(CellBase *c) = 0;
   // Differential equations describing transport of chemicals from cell to cell
   virtual void CelltoCellTransport(Wall *, double *dchem_c1, double *dchem_c2) = 0;
   // Differential equations describing chemical reactions taking place at or near the cell walls
   // (e.g. PIN accumulation)
   virtual void WallDynamics(Wall *w, double *dw1, double *dw)  = 0;
   // Differential equations describing chemical reactions inside the cells
   virtual void CellDynamics(CellBase *c, double *dchem) = 0;
   // to be executed after a cell division
   virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) = 0;
   // to be executed for coloring a cell
   virtual void SetCellColor(CellBase *c, QColor *color) = 0;
   // Number of chemicals
   virtual int NChem(void) = 0;
   // For internal use; not to be redefined by end users
   virtual void SetParameters(Parameter *pass_pars);// { par = pass_pars; }
   virtual void SetCellsStaticDatamembers (CellsStaticDatamembers *cells_static_data_members_of_main);
  protected:
   class Parameter *par;
 };
 Q_DECLARE_INTERFACE(SimPluginInterface, "nl.cwi.VirtualLeaf.SimPluginInterface/1.2")
 Q_DECLARE_METATYPE(SimPluginInterface *)
 #endif
 /* finis */

src/sqr.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  From "Numerical recipes in C"
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _SQR_H_
 #define _SQR_H_
 // redefine these macros as inline functions, to prevent scary
 // behavior.  (According to compiler warnings, the above macros from
 // Numerical Recipes in C are officially undefined...)
 //
 // However, they seem to work, but it seems safer to redefine them.
 // Inline functions will behave like macros anyhow.
 inline double DSQR( double a ) {
   if (a == 0.0) {
     return 0.0;
   } else {
     return a*a;
+  }
+}
 inline float SQR( float a ) {
   if (a == 0.0) {
     return 0.0;
   } else {
     return a*a;
+  }
+}
 #endif
 /* finis */

src/tiny.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _TINY_H_
 #define _TINY_H_
 #define TINY 1e-5
 #endif
 /* finis */

src/transporterdialog.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <QtGui>
 #include <QDoubleValidator>
 #include <sstream>
 #include "canvas.h"
 #include "transporterdialog.h"
 static const std::string _module_id("$Id$");
 TransporterDialog::TransporterDialog(Wall *w, CellBase *c, int wn, QWidget *parent)
-  : wall(w), cell(c), wall_num(wn), QDialog(parent)
+  :  QDialog(parent), wall(w), cell(c), wall_num(wn)
+{
   int frameStyle = QFrame::Plain | QFrame::NoFrame;
   QPushButton *ok = new QPushButton(tr("Ok"));
   QPushButton *cancel = new QPushButton(tr("Cancel"));
   QGridLayout *t_grid = new QGridLayout; // transporter grid
   // connect the slots
   connect(ok, SIGNAL(clicked()), this, SLOT(setTransporterValues()));
   connect(cancel, SIGNAL(clicked()), this, SLOT(close()));
   // compose a label for the dialog box
   std::stringstream label_text;
   label_text << "C("<< wall->C1()->Index() << "," << wall->C2()->Index() << "), N("
 	     << wall->N1()->Index() << "," << wall->N2()->Index() << ")";
   // retrieve the current transporters
   QVector <double> transporters;  // transporter vector
   ntransporters = cell->NChem(); // size of transporter vector
   for (int i=0; i<ntransporters; ++i){
     transporters << ((wall_num == 1) ? wall->Transporters1(i) : wall->Transporters2(i)); // dependent on the wall number of course.
+  }
   // iterate over the vector of transporter values making a label/edit line for each
   for (int i=0; i<transporters.size(); ++i) {
     // label
     label = new QLabel;
     label->setFrameStyle(frameStyle);
     label->setText(QString("%1").arg(i+1)); // cardinal numbering
     // line editor
     QLineEdit *editor = new QLineEdit();
     editors << editor;
     editor->setValidator(new QDoubleValidator(editor)); // validator settings
     // assign the current transporter value
     QString n;
     editor->setText(n.setNum(transporters[i]));
     // insert the label and editor into the transporter grid
     t_grid->addWidget(label, i, 0);
     t_grid->addWidget(editor, i, 1);
+  }
   // add OK and Cancel buttons
   QGridLayout *b_grid = new QGridLayout; // button grid
   b_grid->addWidget(ok, 0, 0);
   b_grid->addWidget(cancel, 0, 1);
   // add both transporter and button grids to the box layout widget
   QVBoxLayout *layout = new QVBoxLayout;
   layout->addLayout(t_grid);
   layout->addLayout(b_grid);
   setLayout(layout);
   setWindowTitle(tr(label_text.str().c_str()));
+}
 void TransporterDialog::setTransporterValues()
+{
   // iterate over the editor widgets soliciting their values and setting the wall's transporters accordingly.
   for (int i=0; i<ntransporters; ++i){
 #ifdef QDEBUG
     qDebug() << "Transporter(" << i << "): " << editors[i]->text().toDouble() << endl;
 #endif
     if (wall_num == 1)
       wall->setTransporters1(i, editors[i]->text().toDouble());
     else
       wall->setTransporters2(i, editors[i]->text().toDouble());
+  }
   editors.resize(0);
   close();
+}
 /* finis */

src/transporterdialog.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _TRANSPORTERDIALOG_H_
 #define _TRANSPORTERDIALOG_H_
 #include <QDialog>
 #include <QVector>
 #include <QLineEdit>
 class QLabel;
 class QLineEdit;
 class Wall;
 class CellBase;
 class TransporterDialog : public QDialog
+{
   Q_OBJECT
  public:
   TransporterDialog(Wall *w, CellBase *c, int wn, QWidget *parent = 0);
   private slots:
   void setTransporterValues();
  private:
   Wall *wall;
   CellBase *cell;
   int wall_num;
   QLabel *label;
   int ntransporters;
   QVector <QLineEdit*> editors;
 };
 #endif
 /* finis */

src/vector.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <stddef.h>
 #include <ostream>
 #include <limits.h>
 #include <stdio.h>
 //#include <math.h>
 #include <stdarg.h>
 #include "sqr.h"
 #include "pi.h"
 #include "vector.h"
 #include "tiny.h"
 static const std::string _module_id("$Id$");
 void Vector::operator=(const Vector &source) {
   // assignment
   // don't assign to self
   if (this==&source) return;
   x=source.x;
   y=source.y;
   z=source.z;
+}
 ostream &Vector::print(ostream &os) const {
   os << "(" << x << ", " << y << ", " << z << ")";
   return os;
+}
 ostream &operator<<(ostream &os, const Vector &v) {
   v.print(os);
   return os;
+}
 Vector Vector::operator+(const Vector &v) const {
   Vector result;
   result.x=x+v.x;
   result.y=y+v.y;
   result.z=z+v.z;
   return result;
+}
 Vector& Vector::operator-=(const Vector &v) {
   x-=v.x;
   y-=v.y;
   z-=v.z;
   return *this;
+}
 Vector Vector::operator/(const double divisor) const {
   Vector result;
   result.x=x/divisor;
   result.y=y/divisor;
   result.z=z/divisor;
   return result;
+}
 Vector Vector::operator*(const double multiplier) const {
   Vector result;
   result.x=x*multiplier;
   result.y=y*multiplier;
   result.z=z*multiplier;
   return result;
+}
 Vector operator*(const double multiplier, const Vector &v) {

src/vector.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
- *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  VirtualLeaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
- *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  VirtualLeaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _VECTOR_H_
 #define _VECTOR_H_
 #include <iostream>
 #include <cmath>
 #include "sqr.h"
 #ifdef QTGRAPHICS
 #include <QPointF>
 #endif
 // three dimensional vector
 using namespace std;
 class Vector {
  public:
   inline Vector(const double cx=0,const double cy=0,const double cz=0) {
     x=cx;
     y=cy;
     z=cz;
   };
   explicit inline Vector(const double m[3]) {
     x=m[0];
     y=m[1];
     z=m[2];
+  }
   // should be taken over by default arguments of Vector constructor
   /*  inline Vector(void) { */
   /*     x=0.; */
   /*     y=0.; */
   /*     z=0.; */
   /*   } */
   inline Vector(const Vector &source) {
     // copy constructor
     x=source.x;
     y=source.y;
     z=source.z;
+  }
   // type conversion from and to QPointF (2D vector class from Qt library; we throw away "z" here!!)
 #ifdef QTGRAPHICS
   inline operator QPointF() const {
     return QPointF( x, y );
+  }
   inline Vector(const QPointF &p) {
     x = p.x();
     y = p.y();
     z = 0.;
+  }
 #endif
   virtual ~Vector() {
   };
   virtual ostream& print(ostream &os) const;
   void operator=(const Vector &source); // assignment operator
   void operator=(const double &s) {
     x=s;
     y=s;
     z=s;
+  }
   Vector operator+(const Vector &v) const; // addition
   inline Vector operator-(const Vector &v) const {
     Vector result;
     result.x=x-v.x;
     result.y=y-v.y;
     result.z=z-v.z;
     return result;
+  }
   Vector &operator-=(const Vector &v);
   inline Vector &operator+=(const Vector &v) {
     x+=v.x;
     y+=v.y;
     z+=v.z;
     return *this;
+  }
   Vector operator/(const double divisor) const; // division by a double
   Vector operator*(const double multiplier) const; // multiply by a scalar (double)
   Vector &operator/=(const double divisor);
   Vector &operator*=(const double multiplier);
   Vector operator*(const Vector &v) const; // cross product
   bool operator==(const Vector &v) const; // comparison
   bool operator< (const Vector &v) const; // order x,y,z
   inline double Norm(void) const {
     return sqrt(DSQR(x)+DSQR(y)+DSQR(z));
+  }
   // Quick and dirty Norm (i.e. Manhattan distance)
   // (e.g. useful if we want to see if the vec is (0,0,0);
   inline double ManhattanNorm(void) const {
     return x+y+z;
+  }
   double SqrNorm(void) const; // gives the square of |v|
   void Normalise(void); // normalise myself
   Vector Normalised(void) const; // return me normalised
   double Angle(const Vector &angle) const; // gives the angle between me and another vector
   double SignedAngle(const Vector &v) const;
   bool SameDirP(const Vector &v);
   double Max(void); // Find max, resp. min value of vector
   double Min(void);
   Vector Perp2D(void) const {
     return Vector(y,-x,0);
+  }
   // data members
   double x,y,z;
   void Dump(ostream &os) const {
     os << x << " " << y << " " << z << " ";
+  }
   void ReadDump(istream &is) {
     is >> x >> y >> z;
+  }
  private:
 };

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)