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

35 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

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.
 	* data_plot.cpp ditto.
 	* forwardeuler.cpp ditto.
 	* mesh.cpp ditto.
 	* mesh.h
 	* random.cpp ditto.
 	* wall.cpp ditto.
 	* wallbase.cpp ditto.
 	* wallitem.cpp ditto.
 -06-07    <guravage@caterpie.sen.cwi.nl>
 	* VirtualLeaf.pro: Removed explicit perl invocation to regerenerate parameter files.
 	* libplugin.pro: ditto.
 -06-03    <guravage@caterpie.sen.cwi.nl>
 	* pardialog.h: Added default versions of this automatically generated file.
 	* pardialog.cpp: ditto.
 	* parameter.h: ditto.
 	* parameter.cpp: ditto.
 	* VirtualLeaf.pro: delete/generate  parameter.{h,cpp}and pardialog.{h,cpp} only if perl is installed.
  	* libplugin.pro: dito.
 	* Makefile: Added top-level Makefile
 -05-10    <guravage@caterpie.sen.cwi.nl>
 	* VirtualLeaf.pro: Added -fPIC option to QMAKE_CXXFLAGS.

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());
 	  //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 += "\n" + c.printednodelist();
+	  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;
 int main(int argc,char **argv) {
   try {
     int c;
     char *leaffile=0;
     char *modelfile=0;
     while (1) {
       //int this_option_optind = optind ? optind : 1;
       int option_index = 0;
       static struct option long_options[] = {
 	{"batch", no_argument, NULL, 'b'},
 	{"leaffile", required_argument, NULL, 'l'},
 	{"model", required_argument, NULL, 'm'}
       };
       // short option 'p' creates trouble for non-commandline usage on MacOSX. Option -p changed to -P (capital)
       static char *short_options = "blm";
       c = getopt_long (argc, argv, "bl:m:",
 		       long_options, &option_index);
       if (c == -1)
 	break;
       if (c==0) {
 	printf ("option %s", long_options[option_index].name);
 	if (optarg)
 	  printf (" with arg %s", optarg);
 	printf ("\n");
 	c = short_options[option_index];
+      }
       switch (c) {
       case 'b':
 	cerr << "Running in batch mode\n";
 	batch=true;
 	break;
       case 'l':
 	leaffile=strdup(optarg);
 	if (!leaffile) {
 	  throw("Out of memory");
+	}
 	printf("Reading leaf state file '%s'\n", leaffile);
 	break;
       case 'm':
 	modelfile=strdup(optarg);
 	if (!modelfile) {
 	  throw("Out of memory");
+	}
 	break;
       case '?':
 	break;
       default:
 	printf ("?? getopt returned character code 0%o ??\n", c);
+      }
+    }
     if (optind < argc) {
       printf ("non-option ARGV-elements: ");
       while (optind < argc)
 	printf ("%s ", argv[optind++]);
       printf ("\n");
+    }
     bool useGUI = !batch;
     qInstallMsgHandler(vlMessageOutput); // custom message handler
     QApplication app(argc,argv,useGUI);
     QPalette tooltippalette = QToolTip::palette();
     QColor transparentcolor = QColor(tooltippalette.brush(QPalette::Window).color());
     tooltippalette.setBrush (QPalette::Window, QBrush (transparentcolor) );
     QToolTip::setPalette( tooltippalette );
     QGraphicsScene canvas(0,0,8000,6000);
     if (useGUI) {
       main_window=new Main(canvas, mesh);
       if ( QApplication::desktop()->width() > ((Main *)main_window)->width() + 10
 	   && QApplication::desktop()->height() > ((Main *)main_window)->height() +30 ) {
 	((Main *)main_window)->show();
 	((Main *)main_window)->resize( ((Main *)main_window)->sizeHint());
       } else {
         ((Main *)main_window)->showMaximized();
+      }
       // show "About" window at start up
       ((Main *)main_window)->about();
     } else {
       main_window=new MainBase(canvas, mesh);
+    }
     canvas.setSceneRect(QRectF());
     if (!batch) {
       QObject::connect( qApp, SIGNAL(lastWindowClosed()), qApp, SLOT(quit()) );
+    }
     // Install model or read catalogue of models
     ModelCatalogue model_catalogue(&mesh, useGUI?(Main *)main_window:0,modelfile);
     if (useGUI)
       model_catalogue.PopulateModelMenu();
     model_catalogue.InstallFirstModel();
     if (leaffile)
       main_window->Init(leaffile);
     Cell::SetMagnification(1);
     Cell::setOffset(0,0);
     main_window->FitLeafToCanvas();
     main_window->Plot();
     if (batch) {
       double t=0.;
       do {
 	t = main_window->TimeStep();
       } while (t < par.maxt);
     } else
       return app.exec();
   } catch (const char *message) {
     if (batch) {
       cerr << "Exception caught:" << endl;
       cerr << message << endl;
       abort();
     } else {
       QString qmess=QString("Exception caught: %1").arg(message);
       QMessageBox::critical(0, "Critical Error", qmess);
       abort();
+    }
   } catch (ios_base::failure) {
     stringstream error_message;
     error_message << "I/O failure: " << strerror(errno);
     if (batch) {
       cerr << error_message.str() <<endl;
       abort();
     } else {
       QString qmess(error_message.str().c_str());
       QMessageBox::critical(0, "I/O Error", qmess );
       abort();
+    }
+  }
+}
 /* finis */

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; "
+}
 # finis

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;
   //angle_line = 0;
   setInteractive(true);
   moving = 0;
   rotation_mode = false;
+}
 void FigureEditor::clear()
+{
   QList<QGraphicsItem *> list = scene()->items();
   QList<QGraphicsItem *>::Iterator it = list.begin();
   for (; it != list.end(); ++it) {
     delete *it;
+  }
+}
 void FigureEditor::wheelEvent(QWheelEvent *event)
+{
   scaleView(pow((double)2, -event->delta() / 240.0));
+}
 void FigureEditor::scaleView (qreal scaleFactor)
+{
   qreal factor = matrix().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)). width();
   if (factor < 0.07 || factor > 100) return;
   scale (scaleFactor, scaleFactor);
+}
 void FigureEditor::Save(const char *fname, const char *format, int sizex, int sizey)
+{
   QImage *image = new QImage(sizex, sizey, QImage::Format_RGB32);
   image->fill(QColor(Qt::white).rgb());
   QPainter *painter=new QPainter(image);
   render(painter);
   image->save(QString(fname),format);
   delete painter;
   delete image;
+}
 void FigureEditor::mousePressEvent(QMouseEvent* e)
+{
   static QList<Node*> selected;
   emit MousePressed();
   //QPointF p = matrix().inverted().map(e->pos());
   QPointF p = mapToScene(e->pos());
 #ifdef QDEBUG
   qDebug() << endl << "MousePressEvent location: (" << p.x() << "," << p.y() << ")." << endl;
   qDebug() << "Magnification:  " << Cell::Magnification() << endl;
   qDebug() << "Offsets:  " << Cell::Offset() << endl;
 #endif
   QList<QGraphicsItem *> l=scene()->items(p);
 #ifdef QDEBUG
   qDebug() << "MousePressEvents, items: " << l.size() << endl;
   qDebug() << "Mouse button modifier: " << e->modifiers() << endl;
 #endif
   if (e->button()==Qt::RightButton || l.size()==0) {
     //cerr << "Drawing an intersection line from " << p.x() << ", " << p.y() << endl;
     intersection_line = new QGraphicsLineItem( 0, scene() );
     intersection_line->setPen( QPen( QColor("red"), 3, Qt::DashLine ) );
     intersection_line->setLine( QLineF(p,p) );
     intersection_line->setZValue( 100 );
     intersection_line->show();
+  }
   for (QList<QGraphicsItem *>::Iterator it=l.begin(); it!=l.end(); ++it) {
 #ifdef QDEBUG
     qDebug() << typeid(**it).name() << endl;
 #endif
     if ( !strcmp(typeid(**it).name(),"8NodeItem")) {
       stringstream data_strstream;
       data_strstream << (dynamic_cast<NodeItem*>(*it))->getNode();
       dynamic_cast<Main *>(parent())->UserMessage(QString(data_strstream.str().c_str()));
       (dynamic_cast<NodeItem*>(*it))->OnClick(e->button());
+    }
     else
       if ( !strcmp(typeid(**it).name(),"8CellItem") ) {
 	Cell &c=((dynamic_cast<CellItem *>(*it))->getCell());
 	// OnClick to be defined in end-user code
 	c.OnClick(e);
       } else {
 	if ( !strcmp(typeid(**it).name(),"8WallItem") ) {
 	  (dynamic_cast<WallItem *>(*it))->OnClick(e);
+	}
+      }
+  }
   FullRedraw();
   moving = 0;
+}
 void FigureEditor::mouseMoveEvent(QMouseEvent* e)
+{
   // User chooses "rotation mode" and we can rotate the object around its center of mass
   if (dynamic_cast<Main *>(parent())->RotationModeP()) {
     QPointF p = mapToScene(e->pos());
     p.setX(p.x() / Cell::Magnification());
     p.setY(p.y() / Cell::Magnification());
     // get object's center of mass
     QPointF rotation_midpoint = mesh.Centroid()*Cell::Factor() - Cell::Offset();
     // calculate rotation angle
     double dy = (rotation_midpoint.y() - p.y());
     double dx = (rotation_midpoint.x() - p.x());
     double new_rot_angle = atan2(dx, dy);
     double d_alpha = new_rot_angle - rot_angle;
     rot_angle = new_rot_angle;
     mesh.Rotate(d_alpha, ( Vector(rotation_midpoint) + Cell::Offset() ) / Cell::Factor() );
     dynamic_cast<Main *>(parent())->Plot(0);
     FullRedraw();
     return;
+  }
   if ( moving ) {
     QPointF p = mapToScene(e->pos());
     moving->userMove(p.x() - moving_start.x(),
 		     p.y() - moving_start.y());
     moving_start = p;
     scene()->update();
+  }
   //cerr << "event";
   // keep track of intersection line to interactively cut a growing leaf
   if ( intersection_line ) {
     QPointF sp = intersection_line -> line().p1(); // startpoint
     QPointF ep = mapToScene(e->pos()); // endpoint
     intersection_line -> setLine( QLineF(sp, ep) );
     scene()->update();
     // Need this for Mac
     FullRedraw();
+  }
+}
 //void FigureEditor::contentsMouseReleaseEvent(QMouseEvent* e)
 void FigureEditor::mouseReleaseEvent(QMouseEvent* e)
+{
   emit MouseReleased();
   // intersection line for leaf was finished now.
   if (e->button()==Qt::LeftButton) {
     if (intersection_line ) {
 #ifdef QDEBUG
       qDebug() << "Trying to cut leaf" << endl;
 #endif
       QPointF sp = intersection_line -> line().p1(); // startpoint
       QPointF ep = mapToScene(e->pos());
       intersection_line -> setLine( QLineF(sp, ep) );
       intersection_line -> show();
       vector <CellItem *> intersected_cells = getIntersectedCells();
       // no cells selected, do nothing
       if (intersected_cells.size()==0) {
 #ifdef QDEBUG
 	qDebug() << "No cells detected :-(" << endl;
 #endif
 	return;
+      }
       Vector startpoint = Vector(sp.x(), sp.y()) / Cell::Factor() - Cell::Offset();
       Vector endpoint = Vector(ep.x(), ep.y()) / Cell::Factor() - Cell::Offset();
       NodeSet *node_set = new NodeSet;
       for (vector<CellItem *>::iterator it = intersected_cells.begin(); it != intersected_cells.end(); it++) {
 	(*it)->setBrush(QBrush("purple"));
 	Cell &c=(*it)->getCell();
 	// sometimes the cell hasn't properly divided yet before the
 	// next division is called?  so check for it?  let's find a way
 	// to do this later. Note that this functionality currently
 	// might result in a segmentation fault for users who are
 	// quickly dragging and releasing division lines...
 	scene()->update();
 #ifdef QDEBUG
 	qDebug() << "Dividing Cell " << c.Index() << endl;
 #endif
 	c.DivideOverGivenLine( startpoint, endpoint, true, node_set);
+      }
       node_set->CleanUp();
       mesh.AddNodeSet(node_set);
 #ifdef QDEBUG
       qDebug() << "Done DivideOverGivenLine" << endl;
 #endif
       mesh.TestIllegalWalls();
       // Do the actual cutting and removing
       if (intersected_cells.size()) {
 	mesh.CutAwayBelowLine( startpoint, endpoint );
 	// Correct flags of nodeset
 	for (NodeSet::iterator i = node_set->begin(); i != node_set->end(); i++) {
 	  (*i)->SetSAM();
 	  (*i)->SetBoundary();
+	}
 	// Make cells attached to nodeset part of the boundary
 	// This is a temporary solution for the following:
 	//   If a cell attached to a NodeSet divides (with a division plane intersecting the node set),
 	//   we must insert a new node into the node set.
 	// For now, we add a layer of "virtual cells" inbetween.
 	list<Cell *> cells_attached_to_nodeset = node_set->getCells();
 	for ( list<Cell *>::iterator c = cells_attached_to_nodeset.begin(); c != cells_attached_to_nodeset.end(); c++) {
 	  (*c)->SetBoundary(Cell::SAM);
+	}
 #ifdef QDEBUG
 	qDebug() << "Done CutAwayBelowLine" << endl;
 #endif
 	mesh.TestIllegalWalls();
 	mesh.RepairBoundaryPolygon();
 #ifdef QDEBUG
 	qDebug() << "Done RepairBoundaryPolygon" << endl;
 #endif
 	mesh.TestIllegalWalls();
 	mesh.CleanUpWalls();
 #ifdef QDEBUG
 	qDebug() << "Done CleanUpWalls" << endl;
 #endif
 	mesh.TestIllegalWalls();
+      }
       dynamic_cast<Main *>(parent())->Plot();
 #ifdef QDEBUG
       cerr << "NodeSet of cutting line: " << *node_set << endl;
 #endif
+    }
   } else
     if (e->button()==Qt::RightButton) {
       if (intersection_line /* && !angle_line*/) {
 	QPointF p = mapToScene(e->pos());
 	QPointF sp = intersection_line->line().p1();
 	viewport()->setMouseTracking( TRUE );
+      }
+    }
+}
 // returns a vector of pointer to cells colliding with intersection line
 vector <CellItem *> FigureEditor::getIntersectedCells(void)
+{
   vector <CellItem *> colliding_cells;
   QList<QGraphicsItem *> l = intersection_line->collidingItems( );
 #ifdef QDEBUG
   qDebug() <<  "l.size() = " << l.size() << endl;
 #endif
   for (QList<QGraphicsItem *>::Iterator it=l.begin(); it!=l.end(); ++it) {
 #ifdef QDEBUG
     qDebug() << typeid(**it).name() << endl;
 #endif
     if ( !strcmp(typeid(**it).name(),"8CellItem") ) {
       colliding_cells.push_back(dynamic_cast<CellItem *>(*it));
+    }
+  }
   delete intersection_line;
   intersection_line = 0;
   return colliding_cells;
+}
 void FigureEditor::FullRedraw(void)
+{
   QList<QRectF> rl;
   rl << sceneRect();
   updateScene(rl);
+}
 NodeItem *FigureEditor::selectedNodeItem(QList<QGraphicsItem *> graphicItems) const
+{
   NodeItem *nodeItem = 0;
   // graphicItems is a list of the QgraphicItems under the mouse click event
   QList<QGraphicsItem *>::Iterator it = graphicItems.begin();
   for (; it != graphicItems.end(); ++it) {
     if ( !strcmp(typeid(**it).name(),"8NodeItem")) {
       // the object under the mouse click is a Nodeitem
       nodeItem = dynamic_cast<NodeItem *>(*it);
       // 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()) );
   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 );
   fd->setFilter( "Parameter files (*.par)");
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     par.Read((const char *)fileName);
+  }
   emit ParsChanged();
+}
 void Main::saveStateXML()
+{
   stopSimulation();
   Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );
   fd->setMode( Q3FileDialog::AnyFile );
   fd->setFilter( "XML (*.xml)");
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     if ( QFile::exists( fileName ) &&
 	 QMessageBox::question(
 			       this,
 			       tr("Overwrite File? -- Leaf Growth"),
 			       tr("A file called %1 already exists."
 				  "Do you want to overwrite it?")
 			       .arg( fileName ),
 			       tr("&Yes"), tr("&No"),
 			       QString::null, 1, 1 ) ) {
       return saveStateXML();
     } else {
       mesh.XMLSave((const char *)fileName, XMLSettingsTree());
+    }
+  }
+}
 void Main::snapshot()
+{
   stopSimulation();
   Q3FileDialog *fd = new Q3FileDialog( this, "Save snapshot", TRUE );
   fd->setMode( Q3FileDialog::AnyFile );
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     if ( QFile::exists( fileName ) &&
 	 QMessageBox::question(
 			       this,
 			       tr("Overwrite File? -- Leaf Growth"),
 			       tr("A file called %1 already exists."
 				  "Do you want to overwrite it?")
 			       .arg( fileName ),
 			       tr("&Yes"), tr("&No"),
 			       QString::null, 1, 1 ) ) {
       return snapshot();
     } else {
       // extract extension from filename
       QString extension = getExtension(fileName);
       // Save bitmaps at 1024x768
       Save((const char *)fileName, extension, 1024, 768);
+    }
+  }
+}
 void Main::readPrevStateXML()
+{
   // 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 );
     QList<QString>::iterator f = xml_files.find( currentFile_nopath );
     if (f == xml_files.end()) {
       return;
+    }
     if (f==xml_files.begin()) {
       QMessageBox mb( "Read previous 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);
+  }
+}
 int Main::readStateXML(const char *filename, bool geometry, bool pars, bool simtime)
+{
   try {
     xmlNode *settings;
     mesh.XMLRead((const char *)filename, &settings, geometry, pars, simtime);
 #ifdef QDEBUG
     qDebug() << "Reading done."<< endl;
 #endif
     XMLReadSettings(settings);
     xmlFree(settings);
     Cell::SetMagnification(1);
     Cell::setOffset(0,0);
     FitLeafToCanvas();
     currentFile =  QString(filename);
     Plot();
     QString status_message = QString("Successfully read leaf from file %1. Time is %2 h.").arg(currentFile).arg(mesh.getTimeHours().c_str());
     cerr << status_message.toStdString() << endl;
     setCaption(caption_with_file.arg(filename));
     statusBar()->message(status_message);
     emit ParsChanged();
 #ifdef QDEBUG
     qDebug() << "Done. Returning 0." << endl;
 #endif
     return 0;
   } catch (const char *error_message) {
     QMessageBox mb( "Read leaf from XML file",
 		    QString(error_message),
 		    QMessageBox::Critical,
 		    QMessageBox::Ok | QMessageBox::Default,
 		    Qt::NoButton,
 		    Qt::NoButton);
     mb.exec();
     return 1;
+  }
+}
 void Main::readNextStateXML()
+{
   // 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 );
     QList<QString>::iterator f = xml_files.find( currentFile_nopath );
     if (f == xml_files.end()) {
       return;
+    }
     ++f;
     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>"
       "<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();
+}
 void Main::toggleHideCells(void)
+{
   Plot();
   editor->FullRedraw();
+}
 void Main::toggleMovieFrames(){}
 void Main::toggleLeafBoundary(){}
 void Main::toggleDynCells() {}
 void Main::startSimulation(void)
+{
   timer->start( 0 );
   statusBar()->message("Simulation started");
   running = true;
+}
 void Main::stopSimulation(void)
+{
   timer->stop();
   cerr << "Stopping simulation" << endl;
   statusBar()->message("Simulation paused");
   running = false;
+}
 void Main::togglePaused()
+{
   bool s = run->isItemChecked(paused_id);
   if (s) {
     cerr << "Calling start simulation" << endl;
     startSimulation();
   } else {
     cerr << "Calling stop simulation" << endl;
     stopSimulation();
+  }
+}
 void Main::setFluxArrowSize(int size)
+{
   flux_arrow_size = size/100.;
+}
 void Main::enlarge()
+{
   canvas.setSceneRect( QRectF( 0,0, canvas.width()*4./3., canvas.height()*4./3.) );
+}
 void Main::shrink()
+{
   canvas.setSceneRect( QRectF( 0,0, canvas.width()*3/4, canvas.height()*3/4) );
+}
 void Main::scale(double factor)
+{
   QMatrix m = editor->matrix();
   m.scale(factor, factor);
   editor->setMatrix( m );
+}
 void Main::zoomIn()
+{
   QMatrix m = editor->matrix();
   m.scale( 1.1, 1.1 );
   editor->setMatrix( m );
+}
 void Main::zoomOut()
+{
   QMatrix m = editor->matrix();
   m.scale( 0.9, 0.9 );
   editor->setMatrix( m );
+}
 void Main::print()
+{
   if ( !printer ) printer = new QPrinter;
   if ( printer->setup(this) ) {
     //    extern Mesh mesh;
     Vector bbll,bbur;
     mesh.BoundingBox(bbll,bbur);
 #ifdef QDEBUG
     qDebug() << "bbll = " << bbll << endl;
     qDebug() << "bbur = " << bbur << endl;
 #endif
     double cw = (bbur.x - bbll.x);
     double ch = (bbur.y - bbll.y);
     QPainter pp(printer);
     QRect vp=pp.viewport();
 #ifdef QDEBUG
     qDebug() << "Paper width = " << vp.width() << " x " << vp.height() << endl;
 #endif
     // Note that Cell is also translated...
     pp.translate(-bbur.x,-bbur.y);
     if (cw>ch) {
       pp.scale(vp.width()/(2*cw*Cell::Magnification()), vp.width()/(2*cw*Cell::Magnification()));
     } else {
       pp.scale(vp.height()/(2*ch*Cell::Magnification()), vp.height()/(2*ch*Cell::Magnification()));
+    }
     canvas.render(&pp, QRectF(), QRectF(0.,0.,canvas.width(),canvas.height()));
+  }
+}
 void Main::TimeStepWrap(void)
+{
   static int t=0;
   TimeStep();
   t++;
   // check number of timesteps
   if (t==par.nit) {
     emit SimulationDone();
+  }
+}
 void Main::RestartSim(void)
+{
   stopSimulation();
   if ( QMessageBox::question(
 			     this,
 			     tr("Restart simulation?"),
 			     tr("Restart simulation.\n"
 				"Are you sure?"),
 			     QMessageBox::Yes | QMessageBox::No, QMessageBox::NoButton ) == QMessageBox::Yes ) {
     cerr << "Restarting simulation" << endl;
     //    extern Mesh mesh;
     mesh.Clear();
     Init();
     Plot();
     editor->FullRedraw();
+  }
   //startSimulation();
+}
 void Main::FitCanvasToWindow(void)
+{
   double scale_factor_x = (double)editor->width()/(double)canvas.width();
   double scale_factor_y = (double)editor->height()/(double)canvas.height();
   double scale_factor = scale_factor_x > scale_factor_y ? scale_factor_x : scale_factor_y;
   QMatrix m = editor->matrix();
 #ifdef QDEBUG
   qDebug() << "editor->width() = " << editor->width() << endl;
   qDebug() << "editor->height() = " << editor->height() << endl;
   qDebug() << "scale_factor = " << scale_factor << endl;
   qDebug() << "scale_factor_x = " << scale_factor_x << endl;
   qDebug() << "scale_factor_y = " << scale_factor_y << endl;
 #endif
   m.scale( scale_factor, scale_factor );
   editor->setMatrix( m );
   editor->show();
+}
 void Main::PauseIfRunning(void)
+{
   if (running) {
     timer->stop();
+  }
+}
 void Main::ContIfRunning(void)
+{
   if (running) {
     timer->start( 0 );
+  }
+}
 void Main::FitLeafToCanvas(void)
+{
   Vector ll,ur;
   mesh.BoundingBox(ll, ur);
   ll*=Cell::Magnification(); ur*=Cell::Magnification();
   // give the leaf some space
   Vector border = ((ur-ll)/5.);
   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();
+}
 void Cell::Apoptose(void)
+{
   // First kill walls
 #ifdef QDEBUG
   qDebug() << "This is cell " << Index() << endl;
   qDebug() << "Number of walls: " << walls.size() << endl;
 #endif
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
 #ifdef QDEBUG
     qDebug() << "Before apoptosis, wall " << (*w)->Index() << " says: c1 = "
 	     << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
 #endif
+  }
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
     bool illegal_flag = false;
     if ((*w)->c1 == (*w)->c2 )
       illegal_flag=true;
     if ((*w)->c1 == this) {
       // invert wall?
       (*w)->c1 = (*w)->c2;
       (*w)->c2 = m->boundary_polygon;
       Node *n1 = (*w)->n1;
       (*w)->n1 = (*w)->n2;
       (*w)->n2 = n1;
     } else {
       (*w)->c2 = m->boundary_polygon;
+    }
 #ifdef QDEBUG
     if (illegal_flag && (*w)->c1==(*w)->c2) {
       qDebug() << "I created an illegal wall." << endl;
+    }
 #endif
     if ( ((*w)->N1()->DeadP() || (*w)->N2()->DeadP()) ||
 	 ((*w)->C1() == (*w)->C2() ) ){
       // kill wall
 #ifdef QDEBUG
       qDebug() << "Killing wall." << endl;
 #endif
       (*w)->Kill();
 #ifdef QDEBUG
       if ((*w)) {
 	qDebug() << "Wall " << (*w)->Index() << " says: c1 = "
 		 << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
+      }
 #endif
       (*w)=0;
     } else {
 #ifdef QDEBUG
       qDebug() << "Not killing wall." << endl;
       qDebug() << "Wall " << (*w)->Index() << " says: c1 = "
 	       << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
 #endif
+    }
+  }
   walls.remove(0);
   // Unregister me from my nodes, and delete the node if it no longer belongs to any cells
   list<Node *> superfluous_nodes;
   for (list<Node *>::iterator n=nodes.begin(); n!=nodes.end(); n++) {
     Node &no(*(*n));
     // locate myself in the node's owner list
     list<Neighbor>::iterator cellpos;
     bool cell_found=false;
     for (list<Neighbor>::iterator nb=no.owners.begin(); nb!=no.owners.end(); nb++) {
       if (nb->cell == this) {
 	cellpos = nb;
 	cell_found = true;
 	break;
+      }
+    }
     if (!cell_found) {
       // I think this cannot happen; but if I am wrong, unpredictable things would happen. So throw an exception.
       throw ("Cell not found in CellBase::Apoptose()\n\rPlease correct the code to handle this situation.");
+    }
     Neighbor tmp = *cellpos;
     no.owners.erase(cellpos);
     // if node has no owners left, or only has a connection to special cell -1 (outside world), mark it as dead.
     if (no.owners.size()==0 || (no.owners.size()==1 && no.owners.front().cell->BoundaryPolP()) ) {
       no.MarkDead();
     } else {
       // register node with outside world
       if (find_if( no.owners.begin(), no.owners.end(),
 		   bind2nd ( mem_fun_ref(&Neighbor::CellEquals), m->boundary_polygon->Index() ) ) == no.owners.end() ) {
 	tmp.cell = m->boundary_polygon;
 	no.owners.push_back(tmp);
+      }
+    }
+  }
   // mark cell as dead
   MarkDead();
+}
 void Cell::ConstructConnections(void)
+{
   // Tie up the nodes of this cell, assuming they are correctly ordered
   //cerr << "Constructing connections of cell " << index << endl;
   for (list<Node *>::iterator i=nodes.begin(); i!=nodes.end(); i++) {
     //cerr << "Connecting node " << *i << endl;
     //cerr << "Node " << *i << endl << " = " << *(*i) << endl;
     // 1. Tidy up existing connections (which are part of this cell)
     if ((*i)->owners.size()>0) {
       list<Neighbor>::iterator neighb_with_this_cell=
 	// remove myself from the neighbor list of the node
 	find_if((*i)->owners.begin(),
 		(*i)->owners.end(),
 		bind2nd(mem_fun_ref( &Neighbor::CellEquals ),this->Index() )  );
       if (neighb_with_this_cell!=(*i)->owners.end())
 	(*i)->owners.erase(neighb_with_this_cell);
+    }
     Node *previous;
     if (i!=nodes.begin()) {
       list<Node *>::iterator previous_iterator=i;
       previous_iterator--;
       previous=*previous_iterator;
     } else {
       previous=nodes.back();
+    }
     Node *next;
     list<Node *>::iterator next_iterator=i;
     next_iterator++;
     if (next_iterator==nodes.end()) {
       next=nodes.front();
     } else {
       next=*next_iterator;
+    }
     (*i)->owners.push_back( Neighbor( this, previous, next ) );
+  }
+}
 bool Cell::DivideOverGivenLine(const Vector v1, const Vector v2, bool fix_cellwall, NodeSet *node_set )
+{
   if (dead) return false;
   // check each edge for intersection with the line
   ItList new_node_locations;
 #ifdef QDEBUG
   qDebug() << "Cell " << Index() << " is doing DivideOverGivenLine" << endl;
 #endif
   for (list<Node *>::iterator i=nodes.begin(); i!=nodes.end(); i++) {
     Vector v3 = *(*i);
     list<Node *>::iterator nb=i;
     nb++;
     if (nb == nodes.end()) {
       nb = nodes.begin();
+    }
     Vector v4 = *(*nb);
     double denominator =
       (v4.y - v3.y)*(v2.x - v1.x) - (v4.x - v3.x)*(v2.y - v1.y);
     double ua =
       ((v4.x - v3.x)*(v1.y - v3.y) - (v4.y - v3.y)*(v1.x -v3.x))/denominator;
     double ub =
       ((v2.x - v1.x)*(v1.y-v3.y) - (v2.y- v1.y)*(v1.x - v3.x))/denominator;
     //cerr << "Edge " << *i << " to " << *nb << ": ua = " << ua << ", ub = " << ub << ":  ";
     // this construction with "TINY" should simulate open/closed interval <0,1]
     if ( ( TINY < ua && ua < 1.+TINY ) && ( TINY < ub && ub < 1.+TINY ) ) {
       // yes, intersection detected. Push the location to the list of iterators
       new_node_locations.push_back(nb);
+    }
+  }
 #ifdef QDEBUG
   if (new_node_locations.size()<2) {
     qDebug() << "Line does not intersect with two edges of Cell " << Index() << endl;
     qDebug() << "new_node_locations.size() = " << new_node_locations.size() << endl;
     return false;
+  }
   ItList::iterator i = new_node_locations.begin();
   list< Node *>::iterator j;
   qDebug() << "-------------------------------" << endl;
   qDebug() << "Location of new nodes: " << (**i)->Index() << " and ";
   ++i;
   j = *i;
   if (j==nodes.begin()) j=nodes.end(); j--;
   qDebug() << (*j)->Index() << endl;
   qDebug() << "-------------------------------" << endl;
   if ( **new_node_locations.begin() == *j ) {
     qDebug() << "Rejecting proposed division (cutting off zero area)." << endl;
     return false;
+  }
 #endif
   DivideWalls(new_node_locations, v1, v2, fix_cellwall, node_set);
   return true;
+}
 // Core division procedure
 void Cell::DivideWalls(ItList new_node_locations, const Vector from, const Vector to, bool fix_cellwall, NodeSet *node_set)
+{
   if (dead) return;
   bool boundary_touched_flag=false;
   // Step 0: keep some data about the parent before dividing
   ParentInfo parent_info;
   parent_info.polarization = ReduceCellAndWalls<Vector>( PINdir );
   parent_info.polarization.Normalise();
   parent_info.PINmembrane = SumTransporters(1);
   parent_info.PINendosome = Chemical(1);
   //cerr << "Parent polarization before division: " << parent_info.polarization << endl;
   // Step 1: create a daughter cell
   Cell *daughter=m->AddCell(new Cell());
   // Step 2: Copy the basics of parent cell to daughter
   for (int i=0;i<NChem();i++) {
     daughter->chem[i]=chem[i];
+  }
   daughter->cell_type = cell_type;
   for (int i=0;i<NChem();i++) {
     daughter->new_chem[i]=new_chem[i];
+  }
   daughter->boundary=boundary;
   daughter->m=m;
   daughter->target_area=target_area/2.;
   target_area/=2;
   daughter->cellvec=cellvec;
   // Division currently only works for convex cells: i.e. if the division line
   // intersects the cells at two points only.
   if (new_node_locations.size()!=2) {
     // Note: if you would add the possibility of dividing non-convex
     // cells, remember to update the code below. There are some
     // fixed-size arrays over there!
     cerr << "Warning in Cell::Division: division of non-convex cells not fully implemented" << endl;
     // Reject the daughter cell and decrement the amount of cells
     // again. We can do this here because it is the last cell added.
     // Never, ever try to fully erase a cell elsewhere, because we
     // make heavy use of cell indices in this project; if you erase a
     // Cell somewhere in the middle of Mesh::Cells the indices will
     // get totally messed up...! (e.g. the indices used in Nodes::cells)
 #ifdef QDEBUG
     qDebug() << "new_node_locations.size() = " << new_node_locations.size() <<endl;
     qDebug() << "daughter->index = " << daughter->index << endl;
     qDebug() << "cells.size() = " << m->cells.size() << endl;
 #endif
     m->cells.pop_back();
     Cell::NCells()--;
     m->shuffled_cells.pop_back();
     return;
+  }
   // We can be sure we only need two positions here because divisions
   // of non-convex cells are rejected above.
   Vector new_node[2];

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(); }
   void Move(Vector T);
   void Move(double dx, double dy, double dz=0) {
     Move( Vector (dx, dy, dz) );
+  }
   double Displace(double dx, double dy, double dh);
   void Displace(void);
   double Energy(void) const;
   bool SelfIntersect(void);
   bool MoveSelfIntersectsP(Node *nid, Vector new_pos);
   bool IntersectsWithLineP(const Vector v1, const Vector v2);
   void XMLAdd(xmlNodePtr cells_node) const;
   void ConstructWalls(void);
   void Flux(double *flux, double *D);
   void OnClick(QMouseEvent *e);
   inline Mesh& getMesh(void) const { return *m; }
   double MeanArea(void);
   void Apoptose(void); // Cell kills itself
   list<Wall *>::iterator RemoveWall( Wall *w );
   void AddWall( Wall *w );
   void Draw(QGraphicsScene *c, QString tooltip = QString::Null());
   // Draw a text in the cell's center
   void DrawText(QGraphicsScene *c, const QString &text) const;
   void DrawIndex(QGraphicsScene *c) const;
   void DrawCenter(QGraphicsScene *c) const;
   void DrawNodes(QGraphicsScene *c) const;
   void DrawAxis(QGraphicsScene *c) const;
   void DrawStrain(QGraphicsScene *c) const;
   void DrawFluxes(QGraphicsScene *c, double arrowsize = 1.);
   void DrawWalls(QGraphicsScene *c) const;
   void DrawValence(QGraphicsScene *c) const;
   void EmitValues(double t);
  signals:
   void ChemMonValue(double t, double *x);
  protected:
   void XMLAddCore(xmlNodePtr xmlcell) const;
   int XMLRead(xmlNode *cur);
   void DivideWalls(ItList new_node_locations, const Vector from, const Vector to, bool wall_fixed = false, NodeSet *node_set = 0);
  private:
   static QPen *cell_outline_pen;
   static double offset[3];
   static double factor;
   Mesh *m;
   void ConstructConnections(void);
   void SetWallLengths(void);
 };
 // Boundarypolygon is a special cell; will not increase ncells
 //  and will not be part of Mesh::cells
 class BoundaryPolygon : public Cell {
  public:
  BoundaryPolygon(void) : Cell() {
     NCells()--;
     index=-1;
+  }
  BoundaryPolygon(double x,double y,double z=0) : Cell (x,y,z) {
     NCells()--;
     index=-1;
+  }
   BoundaryPolygon &operator=(Cell &src) {
     Cell::operator=(src);
     index=-1;
     return *this;
+  }
   virtual void Draw(QGraphicsScene *c, QString tooltip = QString::Null());
   virtual void XMLAdd(xmlNodePtr parent_node) const;
   virtual bool BoundaryPolP(void) const { return true; }
 };
 #endif
 /* finis */

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();
+  }
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
     (*w)->setTransporter(this, ch, conc);
+  }
+}
 ostream &CellBase::print(ostream &os) const
+{
   os << "[ index = " << index << " {" << x << ", " << y << ", " << z << "}: {";
   for (int i=0;i<NChem()-1;i++) {
     os << chem[i] << ", ";
+  }
   os << chem[NChem()-1] << " } ]";
   os << endl << "Nodelist = { " << endl;
   for (list<Node *>::const_iterator i =  nodes.begin(); i!=nodes.end(); i++) {
     os << (*i)->Index() << "( " << *i << ") ";
+  }
   os << " } ";
   for (list<Wall *>::const_iterator i =  walls.begin(); i!=walls.end(); i++) {
     (*i)->print(os);
     os << ", ";
+  }
   os << endl;
   os << " [ area = " << area << " ]";
   os << " [ walls = ";
   for (list<Wall *>::const_iterator i= walls.begin(); i!=walls.end(); i++) {
     os << (*i)->n1->Index() << " -> " << (*i)->n2->Index() << ", " <<  (*i)->c1->Index() << " | " << (*i)->c2->Index() << ", ";
+  }
   os << " ] ";
   os << "div_counter = " << div_counter << endl;
   os << "cell_type = " << cell_type << endl;
   os << endl;
   return os;
+}
 ostream &operator<<(ostream &os, const CellBase &c)
+{
   c.print(os);
   return os;
+}
 double CellBase::CalcArea(void) const
+{
   double loc_area=0.;
   for (list<Node *>::const_iterator i=nodes.begin(); i!=(nodes.end()); i++) {
     list<Node *>::const_iterator i_plus_1=i; i_plus_1++;
     if (i_plus_1==nodes.end())
       i_plus_1=nodes.begin();
     loc_area+= (*i)->x * (*i_plus_1)->y;
     loc_area-= (*i_plus_1)->x * (*i)->y;
+  }
   // http://technology.niagarac.on.ca/courses/ctec1335/docs/arrays2.pdf
   return fabs(loc_area)/2.0;
+}
 Vector CellBase::Centroid(void) const
+{
   double area=0.;
   double integral_x_dxdy=0.,integral_y_dxdy=0.;
   for (list<Node *>::const_iterator i=nodes.begin(); i!=(nodes.end()); i++) {
     list<Node *>::const_iterator i_plus_1=i; i_plus_1++;
     if (i_plus_1==nodes.end())
       i_plus_1=nodes.begin();
     area+= (*i)->x * (*i_plus_1)->y;
     area-= (*i_plus_1)->x * (*i)->y;
     integral_x_dxdy+=
       ((*i_plus_1)->x+(*i)->x)*
       ((*i)->x*(*i_plus_1)->y-
        (*i_plus_1)->x*(*i)->y);
     integral_y_dxdy+=
       ((*i_plus_1)->y+(*i)->y)*
       ((*i)->x*(*i_plus_1)->y-
        (*i_plus_1)->x*(*i)->y);
+  }
   area = fabs(area)/2.0;
   integral_x_dxdy/=6.;
   integral_y_dxdy/=6.;
   Vector centroid(integral_x_dxdy,integral_y_dxdy,0);
   centroid/=area;
   return centroid;
+}
 void CellBase::SetIntegrals(void) const
+{
   // Set the initial values for the integrals over x^2,
   // xy, yy, x, and y
   // these values will be updated after each move of the CellBase wall
   intgrl_xx=0.; intgrl_xy=0.; intgrl_yy=0.;
   intgrl_x=0.; intgrl_y=0.;
   area=0.;
   list<Node *>::const_iterator nb;
   list<Node *>::const_iterator i=nodes.begin();
   for (; i!=(nodes.end()); i++) {
     nb = i; nb++; if (nb==nodes.end()) nb=nodes.begin();
     area+=(*i)->x*(*nb)->y;
     area-=(*nb)->x*(*i)->y;
     intgrl_xx+=
       ((*i)->x*(*i)->x+
        (*nb)->x*(*i)->x+
        (*nb)->x*(*nb)->x ) *
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
     intgrl_xy+=
       ((*nb)->x*(*i)->y-
        (*i)->x*(*nb)->y)*
       ((*i)->x*(2*(*i)->y+(*nb)->y)+
        (*nb)->x*((*i)->y+2*(*nb)->y));
     intgrl_yy+=
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y)*
       ((*i)->y*(*i)->y+
        (*nb)->y*(*i)->y+
        (*nb)->y*(*nb)->y );
     intgrl_x+=
       ((*nb)->x+(*i)->x)*
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
     intgrl_y+=
       ((*nb)->y+(*i)->y)*
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
+  }
   area = fabs(area)/2.0;
+}
 double CellBase::Length(Vector *long_axis, double *width)  const
+{
   // Calculate length and axes of CellBase
   // Calculate inertia tensor
   // see file inertiatensor.nb for explanation of this method
   if (!lambda_celllength) {
     // Without length constraint we do not keep track of the cells'
     // moments of inertia. So we must calculate them here.
     SetIntegrals();
+  }
   double intrx=intgrl_x/6.;
   double intry=intgrl_y/6.;
   double ixx=(intgrl_xx/12.)-(intrx*intrx)/area;
   double ixy=(intgrl_xy/24.)+(intrx*intry)/area;
   double iyy=(intgrl_yy/12.)-(intry*intry)/area;
   double rhs1=(ixx+iyy)/2., rhs2=sqrt( (ixx-iyy)*(ixx-iyy)+4*ixy*ixy )/2.;
   double lambda_b=rhs1+rhs2;
   // see: http://scienceworld.wolfram.com/physics/MomentofInertiaEllipse.html
   //    cerr << "n = " << n << "\n";
   if (long_axis) {
     *long_axis = Vector(-ixy, lambda_b - ixx, 0);
     //   cerr << "ixx = " << ixx << ", ixy = " << ixy << ", iyy = " << iyy << ", area = " << area << endl;
+  }
   if (width) {
     *width = 4*sqrt((rhs1-rhs2)/area);
+  }
   return 4*sqrt(lambda_b/area);
+}
 double CellBase::CalcLength(Vector *long_axis, double *width)  const
+{
   // Calculate length and axes of CellBase, without touching cells raw moments
   // Calculate inertia tensor
   // see file inertiatensor.nb for explanation of this method
   double my_intgrl_xx=0., my_intgrl_xy=0., my_intgrl_yy=0.;
   double my_intgrl_x=0., my_intgrl_y=0., my_area=0.;
   my_area=0.;
   list<Node *>::const_iterator nb;
   list<Node *>::const_iterator i=nodes.begin();
   for (; i!=(nodes.end()); i++) {
     nb = i; nb++; if (nb==nodes.end()) nb=nodes.begin();
     my_area+=(*i)->x*(*nb)->y;
     my_area-=(*nb)->x*(*i)->y;
     my_intgrl_xx+=
       ((*i)->x*(*i)->x+
        (*nb)->x*(*i)->x+
        (*nb)->x*(*nb)->x ) *
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
     my_intgrl_xy+=
       ((*nb)->x*(*i)->y-
        (*i)->x*(*nb)->y)*
       ((*i)->x*(2*(*i)->y+(*nb)->y)+
        (*nb)->x*((*i)->y+2*(*nb)->y));
     my_intgrl_yy+=
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y)*
       ((*i)->y*(*i)->y+
        (*nb)->y*(*i)->y+
        (*nb)->y*(*nb)->y );
     my_intgrl_x+=
       ((*nb)->x+(*i)->x)*
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
     my_intgrl_y+=
       ((*nb)->y+(*i)->y)*
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
+  }
   //my_area/=2.0;
   my_area = fabs(my_area)/2.0;
   double intrx=my_intgrl_x/6.;
   double intry=my_intgrl_y/6.;
   double ixx=(my_intgrl_xx/12.)-(intrx*intrx)/my_area;
   double ixy=(my_intgrl_xy/24.)+(intrx*intry)/my_area;
   double iyy=(my_intgrl_yy/12.)-(intry*intry)/my_area;
   double rhs1=(ixx+iyy)/2., rhs2=sqrt( (ixx-iyy)*(ixx-iyy)+4*ixy*ixy )/2.;
   double lambda_b=rhs1+rhs2;
   // see: http://scienceworld.wolfram.com/physics/MomentofInertiaEllipse.html
   //    cerr << "n = " << n << "\n";
   if (long_axis) {
     *long_axis = Vector(-ixy, lambda_b - ixx, 0);
     //   cerr << "ixx = " << ixx << ", ixy = " << ixy << ", iyy = " << iyy << ", my_area = " << my_area << endl;
+  }
   if (width) {
     *width = 4*sqrt((rhs1-rhs2)/my_area);
+  }
   return 4*sqrt(lambda_b/my_area);
+}
 void CellBase::ConstructNeighborList(void)
+{
   neighbors.clear();
   for (//list<Wall *>::const_reverse_iterator wit=walls.rbegin();
        list<Wall *>::const_iterator wit=walls.begin();
        // somehow the reverse_iterator returns by walls needs to be casted to const to let this work.
        // it seems to me it is a bug in the STL implementation...
        wit!=walls.end();
        wit++) {
     if ((*wit)->C1() != this) {
       neighbors.push_back((*wit)->C1());
     } else {

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)
+  {
     if (bound!=None) {
+    }
     return boundary=bound;
+  }
   boundary_type ResetBoundary(void) { return boundary=None; }
   boundary_type Boundary(void) const { return boundary; }
   static int &NChem(void) { return static_data_members->nchem; }
   double CalcArea(void) const;
   double RecalcArea(void) { return area = CalcArea(); }
   Vector Centroid(void) const;
   void SetIntegrals(void) const;
   double Length(Vector *long_axis = 0, double *width = 0) const;
   double CalcLength(Vector *long_axis = 0, double *width = 0) const;
   inline int Index(void) const { return index; }
   void SetTargetArea(double tar_ar) { target_area=tar_ar; }
   inline void SetTargetLength(double tar_l) { target_length=tar_l; }
   inline void SetLambdaLength(double lambda_length) { lambda_celllength = lambda_length; }
   inline double TargetArea(void) { return target_area; }
   inline void SetStiffness(double stiff) { stiffness = stiff; }
   inline double Stiffness(void) { return stiffness; }
   inline double EnlargeTargetArea(double da) { return target_area+=da; }
   inline double Area(void) const { return area; }
   inline void Divide(void) { flag_for_divide = true; }
   inline void DivideOverAxis(const Vector &v)
+  {
     division_axis = new Vector(v);
     flag_for_divide = true;
+  }
   inline double Circumference(void) const {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum +=  (*w)->Length();
+    }
     return sum;
+  }
   QList<WallBase *> getWalls(void) {
     QList<WallBase *> wall_list;
     for (list<Wall *>::iterator i=walls.begin();
 	 i!=walls.end();
 	 i++) {
       wall_list << *i;
+    }
     return wall_list;
+  }
   void Dump(ostream &os) const;
   QString printednodelist(void);
   inline bool DeadP(void) { return dead; }
   inline void MarkDead(void) { dead  = true; }
   static double &BaseArea(void)
+  {
     return static_data_members->base_area;
+  }
   void CheckForDivision(void);
   // write flux from neighboring cells into "flux"
   void Flux(double *flux, double *D);
   inline bool FixedP(void) { return fixed; }
   inline bool Fix(void) {  FixNodes(); return (fixed=true); }
   inline bool Unfix(void) { UnfixNodes(); return (fixed=false);}
   inline void setCellVec(Vector cv) { cellvec = cv; }
   bool AtBoundaryP(void) const;
   static inline int &NCells(void)
+  {
     return static_data_members->ncells;
+  }
   inline void Mark(void)
+  {
     marked=true;
+  }
   inline void Unmark(void)
+  {
     marked=false;
+  }
   inline bool Marked(void) const {
     return marked;
+  }
   //! Returns the sum of chemical "chem" of this CellBase's neighbors
   double SumChemicalsOfNeighbors(int chem)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum +=  (*w)->Length() * ( (*w)->c1!=this ? (*w)->c1->Chemical(chem) : (*w)->c2->Chemical(chem) );
+    }
     return sum;
+  }
   //! Generalization of the previous member function
   template<class P, class Op> P ReduceNeighbors(Op f) {
     P sum=0;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += (*w)->c1 != this ? f( *((*w)->c1) ) : f ( *((*w)->c2) );
+    }
     return sum;
+  }
   //! The same, but now for the walls
   template<class P, class Op> P ReduceWalls(Op f, P sum) {
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += f( **w );
+    }
     return sum;
+  }
   //! The same, but now for the walls AND neighbors
   template<class P, class Op> P ReduceCellAndWalls(Op f)
+  {
     P sum = 0;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += ((*w)->c1 == this) ?
 	f( ((*w)->c1), ((*w)->c2), *w ) :
 	f( ((*w)->c2), ((*w)->c1), *w );
+    }
     return sum;
+  }
   //! Sum transporters at this CellBase's side of the walls
   double SumTransporters(int ch)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += (*w)->getTransporter(this, ch);
+    }
     return sum;
+  }
   inline int NumberOfDivisions(void) { return div_counter; }
   //! Sum transporters at this CellBase's side of the walls
   double SumLengthTransporters(int ch)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += (*w)->getTransporter(this, ch) * (*w)->Length();
+    }
     return sum;
+  }
   double SumLengthTransportersChemical(int trch, int ch)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += (*w)->getTransporter(this, trch) * ( (*w)->c1!=this ? (*w)->c1->Chemical(ch) : (*w)->c2->Chemical(ch) );
+    }
     return sum;
+  }
   inline int CellType(void) const { return cell_type; }
   inline void SetCellType(int ct) { cell_type = ct; }
   static void SetNChem(int new_nchem)
+  {
     if (NCells()) {
       MyWarning::error("CellBase::SetNChem says: not permitted, call SetNChem after deleting all cells.");
     } else {
       NChem() = new_nchem;
+    }
+  }
   inline double TargetLength() const { return target_length; }
   static inline CellsStaticDatamembers *GetStaticDataMemberPointer(void) { return static_data_members; }
  protected:
   // (define a list of Node* iterators)
   typedef list < list<Node *>::iterator > ItList;
   int index;
   inline void SetChemToNewchem(void)
+  {
     for (int c=0;c<CellBase::NChem();c++) {
       chem[c]=new_chem[c];
+    }
+  }
   inline void SetNewChemToChem(void)
+  {
     for (int c=0;c<CellBase::NChem();c++) {
       new_chem[c]=chem[c];
+    }
+  }
   inline double NewChem(int c) const { return new_chem[c]; }
  protected:
   list<Node *> nodes;
   void ConstructNeighborList(void);
   long wall_list_index (Wall *elem) const;
   // DATA MEMBERS
   // list of nodes, in clockwise order
   // a (non-ordered) list of neighboring cells (actually I think the
   // introduction of ConstructWalls() has made these
   // lists ordered (clockwise), but I am not yet 100% sure...).
   list<CellBase *> neighbors;
   list<Wall *> walls;
   double *chem;
   double *new_chem;
   boundary_type boundary;
   mutable double area;
   double target_area;
   double target_length;
   double lambda_celllength;
   double stiffness; // stiffness like in Hogeweg (2000)
   bool fixed;
   bool pin_fixed;
   bool at_boundary;
   bool dead;
   bool flag_for_divide;
   Vector *division_axis;
   int cell_type;
   // for length constraint
   mutable double intgrl_xx, intgrl_xy, intgrl_yy, intgrl_x, intgrl_y;
   bool source;
   Vector cellvec;
   // STATIC DATAMEMBERS MOVED TO CLASS
   static CellsStaticDatamembers *static_data_members;
   double source_conc;
   int source_chem;
   // PRIVATE MEMBER FUNCTIONS

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];
+  }
   delete[] dydx;
   delete[] y;
   return; //Normal exit.
+}
 /* finis */

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
   Vector result;
   result.x = mat[0][0]*v.x+mat[0][1]*v.y+mat[0][2]*v.z;
   result.y = mat[1][0]*v.x+mat[1][1]*v.y+mat[1][2]*v.z;
   result.z = mat[2][0]*v.x+mat[2][1]*v.y+mat[2][2]*v.z;
   return result;
+}
 bool Matrix::operator==(Matrix &m) const
+{
   for (int i=0;i<9;i++) {
     if ((mat[0][i]-m.mat[0][i])>TINY)
       return false;
+  }
   return true;
+}
 double Matrix::Det(void) const
+{
   return
     - mat[0][2]*mat[0][4]*mat[0][6]
     + mat[0][1]*mat[0][5]*mat[0][6]
     + mat[0][2]*mat[0][3]*mat[0][7]
     - mat[0][0]*mat[0][5]*mat[0][7]
     - mat[0][1]*mat[0][3]*mat[0][8]
     + mat[0][0]*mat[0][4]*mat[0][8];
+}
 Matrix Matrix::Inverse(void) const
+{
   // return the Inverse of this matrix
   double rd=1./Det(); // Reciproce Det;
   Matrix inverse;
   inverse.mat[0][0]=rd*(-mat[0][5]*mat[0][7]+mat[0][4]*mat[0][8]);
   inverse.mat[0][1]=rd*( mat[0][2]*mat[0][7]-mat[0][1]*mat[0][8]);
   inverse.mat[0][2]=rd*(-mat[0][2]*mat[0][4]+mat[0][1]*mat[0][5]);
   inverse.mat[0][3]=rd*( mat[0][5]*mat[0][6]-mat[0][3]*mat[0][8]);
   inverse.mat[0][4]=rd*(-mat[0][2]*mat[0][6]+mat[0][0]*mat[0][8]);
   inverse.mat[0][5]=rd*( mat[0][2]*mat[0][3]-mat[0][0]*mat[0][5]);
   inverse.mat[0][6]=rd*(-mat[0][4]*mat[0][6]+mat[0][3]*mat[0][7]);
   inverse.mat[0][7]=rd*( mat[0][1]*mat[0][6]-mat[0][0]*mat[0][7]);
   inverse.mat[0][8]=rd*(-mat[0][1]*mat[0][3]+mat[0][0]*mat[0][4]);
   return inverse;
+}
 void Matrix::Rot2D(double theta)
+{
   // make this matrix a rotation matrix over theta
   // see http://mathworld.wolfram.com/RotationMatrix.html
   mat[0][0] = cos(theta); mat[0][1]=sin(theta);
   mat[1][0] = -sin(theta); mat[1][1]=cos(theta);
   mat[0][2] = mat[1][2] = mat[2][0] = mat[2][1] = mat[2][2] = 0.;
+}
 /* finis */

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);
+  }
   double sum_l=0; int n_l=0;
   for (list<Node *>::const_iterator i=cell->nodes.begin(); i!=cell->nodes.end(); i++) {
     list<Node *>::const_iterator nb=i; nb++;
     if (nb==cell->nodes.end())
       nb=cell->nodes.begin();
     double l = (**nb-**i).Norm();
     sum_l += l;
     n_l++;
+  }
   Node::target_length = sum_l/(double)n_l;
   // a bit more tension
   Node::target_length/=4.;
   SetBaseArea();
+}
 Cell *Mesh::RectangularCell(const Vector ll, const Vector ur, double rotation) {
   Cell *cell=AddCell(new Cell());
   cell->m=this;
   Matrix rotmat;
   rotmat.Rot2D(rotation); // rotation over 0,0
   Node *n1=AddNode(new Node(rotmat * ll));
   Node *n2=AddNode(new Node(rotmat * Vector(ll.x, ur.y,0)));
   Node *n3=AddNode(new Node(rotmat * ur));
   Node *n4=AddNode(new Node(rotmat * Vector(ur.x, ll.y,0)));
   n1->boundary=true;
   n2->boundary=true;
   n3->boundary=true;
   n4->boundary=true;
   //n1.fixed=n2.fixed=n3.fixed=n4.fixed=true;
   AddNodeToCell(cell, n4,
 		n1,
 		n3);
   AddNodeToCell(cell, n3,
 		n4,
 		n2);
   AddNodeToCell(cell, n2,
 		n3,
 		n1);
   AddNodeToCell(cell, n1,
 		n2,
 		n4);
   AddNodeToCell(boundary_polygon, n4,
 		n1,
 		n3);
   AddNodeToCell(boundary_polygon, n3,
 		n4,
 		n2);
   AddNodeToCell(boundary_polygon, n2,
 		n3,
 		n1);
   AddNodeToCell(boundary_polygon, n1,
 		n2,
 		n4);
   cell->setCellVec(Vector(0,1,0));
   boundary_polygon->m = this;
   boundary_polygon->area = 0;
   cell->area = cell->CalcArea();
   // target length is the length of the elements
   Node::target_length = ur.y-ll.y;
   // a bit more tension
   Node::target_length/=2;
   cell->SetIntegrals();
   cell->ConstructNeighborList();
   return cell;
+}
 Cell &Mesh::EllipticCell(double xc, double yc, double ra, double rb,  int nnodes, double rotation) {
   int first_node=Node::nnodes;
   //  nodes.reserve(nodes.size()+nnodes);
   //cells.push_back(Cell(xc,yc));
   Cell *c=AddCell(new Cell(xc,yc));
   c->m=this;
   for (int i=0;i<nnodes;i++) {
     double angle=2*Pi*(i/(double)nnodes);
     double x=xc+ra*cos(angle)*cos(rotation) - rb*sin(angle)*sin(rotation);
     double y=yc+ra*cos(angle)*sin(rotation) + rb*sin(angle)*cos(rotation);
     Node *n=AddNode(new Node(x,y,0));
     n->boundary = true;
+  }
   for (int i=0;i<nnodes;i++) {
     AddNodeToCell(c,
 		  nodes[first_node + i],
 		  nodes[first_node+ (nnodes+i-1)%nnodes],
 		  nodes[first_node+ (i + 1)%nnodes]);
     AddNodeToCell(boundary_polygon,
 		  nodes[first_node + i],
 		  nodes[first_node+ (nnodes+i-1)%nnodes],
 		  nodes[first_node+ (i + 1)%nnodes]);
+  }
   boundary_polygon->m = this;
   boundary_polygon->area = 0;
   c->area = c->CalcArea();
   // target length is the length of the elements
   Node::target_length = (2 * ((ra +rb)/2.) * sin (Pi/nnodes));
   // a bit more tension
   Node::target_length/=2;
   c->SetIntegrals();
   c->at_boundary=true;
   return *c;
+}
 Cell &Mesh::LeafPrimordium(int nnodes, double pet_length) {
   // first leaf cell
   int first_node=Node::nnodes;
   Cell *circle=AddCell(new Cell(0,0));
   circle->m=this;
   const double ra=10, rb=10;
   const double xc=0,yc=0;
   const double rotation=0;
   for (int i=0;i<nnodes;i++) {
     double angle=2*Pi*(i/(double)nnodes);
     double x=xc+ra*cos(angle)*cos(rotation) - rb*sin(angle)*sin(rotation);
     double y=yc+ra*cos(angle)*sin(rotation) + rb*sin(angle)*cos(rotation);
     Node *n=AddNode(new Node(x,y,0));
     /* if (angle > 1.25*Pi && angle < 1.75*Pi ) {
        n.sam = true;
        }*/
     AddNodeToCell(circle,
 		  n,
 		  nodes[first_node+ (nnodes+i-1)%nnodes],
 		  nodes[first_node+ (i + 1)%nnodes]);
+  }
   boundary_polygon->m = this;
   boundary_polygon->area = 0;
   circle->area = circle->CalcArea();
   // target length is the length of the elements
   Node::target_length = (2 * ((ra +rb)/2.) * sin (Pi/nnodes));
   // a bit more tension
   Node::target_length/=2;
   circle->SetIntegrals();
   //return c;
   circle->SetTargetArea(2*circle->Area());
   // Petiole: starts at both sides of the circular cell
   // get position of the (n/4)'th and (3*(n/4))'th node.
   list<Node *>::reverse_iterator it_n1=circle->nodes.rbegin();
   for (int i=0; i<nnodes/2; i++)
     it_n1++;
   it_n1--;
   list<Node *>::reverse_iterator it_n2=--circle->nodes.rend();
   Cell *petiole=AddCell(new Cell());
   Node *n1 = *it_n1;
   Node *n2 = *it_n2;
   Node *n3=AddNode( new Node ( *n2 + Vector( 0, pet_length, 0) ) );
   Node *n4=AddNode( new Node ( *n1 + Vector( 0, pet_length, 0) ) );
   n3->boundary=true;
   n4->boundary=true;
   AddNodeToCell(petiole, *it_n1,
 		n4,
 		nodes[(*it_n2)->Index()
 		      + (( (*it_n1)->Index() - (*it_n2)->Index() )-1+nnodes)%nnodes]);
   list<Node *>::reverse_iterator i=it_n1; i++;
   for (; i!=it_n2; ++i) {
     AddNodeToCell(petiole, *i,
 		  nodes[(*it_n2)->Index() + (((*i)->Index()-(*it_n2)->Index()) + 1)%nnodes],
 		  nodes[(*it_n2)->Index() + (((*i)->Index()-(*it_n2)->Index())-1+nnodes)%nnodes]);
+  }
   AddNodeToCell(petiole, *it_n2, *it_n2 + 1, n3);
   (*it_n2)->boundary=true;
   AddNodeToCell(petiole, n3, n2, n4);
   AddNodeToCell(petiole, n4, n3, n1);
 #ifdef QDEBUG
   qDebug() << circle << endl;
   qDebug() << petiole << endl;
 #endif
   AddNodeToCell(boundary_polygon, *it_n1, n4, *it_n2 + ((*it_n1-*it_n2)+1)%nnodes); // is this gonna work?
   (*it_n1)->boundary=true;
   for (int i=0;i<nnodes;i++) {
     if (nodes[(first_node + i)]->owners.size()==1) {
       AddNodeToCell(boundary_polygon,
 		    nodes[first_node +i],
 		    nodes[first_node+ (nnodes+i-1)%nnodes],
 		    nodes[first_node+ (i + 1)%nnodes]);
       nodes[first_node+i]->boundary=true;
+    }
+  }
   AddNodeToCell(boundary_polygon, *it_n2, nodes[(nnodes+(*it_n2)->Index() - 1)%nnodes], n3);
   AddNodeToCell(boundary_polygon, n3, n2, n4);
   AddNodeToCell(boundary_polygon, n4, n3, n1);
   // make petiole solid
   for (list<Node *>::iterator i=petiole->nodes.begin(); i!=petiole->nodes.end(); i++) {
     (*i)->Fix();
+  }
   petiole->Fix();
   petiole->area=petiole->CalcArea();
   petiole->target_area=petiole->area;
   petiole->ConstructNeighborList();
   circle->ConstructNeighborList();
   boundary_polygon->ConstructConnections();
   boundary_polygon->ConstructNeighborList();
   circle->setCellVec(Vector(0,1,0));
   return *circle;
+}
 /*Cell &Mesh::Box() {
   }*/
 // return bounding box of mesh
 void Mesh::BoundingBox(Vector &LowerLeft, Vector &UpperRight) {
   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)) -
 	      (i_min_1.x*old_p.y-
 	       old_p.x*i_min_1.y)*
 	      (old_p.x*(2*old_p.y+i_min_1.y)+
 	       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);
       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()) {
       (*w)=0;
+    }
+  }
   boundary_polygon->walls.remove(0);
   // Renumber cells; this is most efficient if the list of dead cell indices is sorted
   sort(cellind.begin(),cellind.end());
   // Reindexing of Cells
   for (vector<int>::reverse_iterator j=cellind.rbegin(); j!=cellind.rend(); j++) {
     for (vector<Cell *>::reverse_iterator i=cells.rbegin(); i!=cells.rend(); i++) {
       if (*j < (*i)->index) (*i)->index--;
+    }
+  }
   // Actual deleting of Cells
   // We must delete in reverse order, otherwise the iterators become redefined
   for ( CellItVect::reverse_iterator i=cellstoberemoved.rbegin(); i!=cellstoberemoved.rend(); i++) {
     Cell::NCells()--;
     cells.erase(*i);
+  }
   // same for nodes
   typedef vector <vector<Node *>::iterator> NodeItVect;
   NodeItVect nodestoberemoved;
   vector<int> nodeindlist;
   // collect iterators and indices of dead nodes
   for (vector<Node *>::iterator i=nodes.begin(); i!=nodes.end(); i++) {
     if ((*i)->DeadP()) {
       nodestoberemoved.push_back( i );
       nodeindlist.push_back((*i)->index);
+    }
+  }
   // sort the list of dead nodes for renumbering
   sort(nodeindlist.begin(),nodeindlist.end());
   // Reindicing of Nodes
   for (vector<int>::reverse_iterator j=nodeindlist.rbegin(); j!=nodeindlist.rend(); j++) {
     for (vector<Node *>::reverse_iterator i=nodes.rbegin(); i!=nodes.rend(); i++) {
       if (*j < (*i)->index) {
 	(*i)->index--;
+      }
+    }
+  }
   // Actual deleting of nodes
   // We must delete in reverse order, otherwise the iterators become redefined
   for ( NodeItVect::reverse_iterator i=nodestoberemoved.rbegin(); i!=nodestoberemoved.rend(); i++) {
     Node::nnodes--;
     nodes.erase(*i);
+  }
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
     if ((*w)->DeadP()) {
       Wall::nwalls--;
       delete *w;
       *w = 0;
+    }
+  }
   walls.remove( 0 );
   // Clean up all intercellular connections and redo everything
   for (vector<Node *>::iterator i=nodes.begin(); i!=nodes.end(); i++) {
     (*i)->owners.clear();
+  }
   for (vector<Cell *>::iterator i=cells.begin(); i!=cells.end(); i++) {
     (*i)->ConstructConnections();
+  }
   boundary_polygon->ConstructConnections();
   // remake shuffled_nodes and shuffled cells
   shuffled_nodes.clear();
   shuffled_nodes = nodes;
   shuffled_cells.clear();
   shuffled_cells = cells;
+}
 void Mesh::CutAwayBelowLine( Vector startpoint, Vector endpoint) {
   // Kills all cells below the line startpoint -> endpoint
   Vector perp = (endpoint-startpoint).Perp2D().Normalised();
 #ifdef QDEBUG
   qDebug() << "Before Apoptose" << endl;
 #endif
   TestIllegalWalls();
   for (vector<Cell *>::iterator i=cells.begin(); i!=cells.end(); i++) {
     // do some vector geometry to check whether the cell is below the cutting line
     Vector cellvec = ((*i)->Centroid()-startpoint);
     if ( InnerProduct(perp, cellvec) < 0 ) {
       // remove those cells
       (*i)->Apoptose();
+    }
+  }
 #ifdef QDEBUG
   qDebug() << "Before CleanUpCellNodeLists" << endl;
 #endif
   TestIllegalWalls();
   CleanUpCellNodeLists();
+}
 void Mesh::CutAwaySAM(void) {
   for (vector<Cell *>::iterator i=cells.begin(); i!=cells.end(); i++) {
     if( (*i)->Boundary() == Cell::SAM ) {
       (*i)->Apoptose();
+    }
+  }
   TestIllegalWalls();
   CleanUpCellNodeLists();
+}
 void Mesh::TestIllegalWalls(void) {
   for (list<Wall *>::iterator w = walls.begin(); w!=walls.end(); w++) {
     if ((*w)->IllegalP() ) {
 #ifdef QDEBUG
       cerr << "Wall " << **w << " is illegal." << endl;
 #endif
+    }
+  }
+}
 class node_owners_eq : public unary_function<Node, bool> {
   int no;
 public:
   explicit node_owners_eq(int nn) { no=nn; }
   bool operator() (const Node &n) const {
     if (n.CellsSize()==1)
       return true;
     else
       return false;
+  }
 };
 void Mesh::RepairBoundaryPolygon(void) {
   // After serious manipulations (e.g. after cutting part off the
   // leaf) repair the boundary polygon. It assumes the cut line has
   // already been marked "boundary" and the original boundary marks
   // were not removed.
   //
   // So, this function just puts boundary nodes into the boundary
   // polygon in the right order; it cannot detect boundaries from
   // scratch.
   Node *boundary_node=0, *next_boundary_node=0, *internal_node;
   set<int> original_boundary_nodes, repaired_boundary_nodes;
   vector<int> difference; // set difference result
   // Step 0: print out current boundary polygon
 #ifdef QDEBUG
   qDebug() << endl << "Original Boundary Polygon node indices: ";
   foreach (Node* node, boundary_polygon->nodes) {
     qDebug() << node->Index() << " " ;
+  }
   qDebug() << endl << endl;
 #endif
   // Step 1a: Create a set containing the current boundary polygon nodes' Indices.
   foreach (Node* node, boundary_polygon->nodes) {
     original_boundary_nodes.insert(node->Index());
+  }
   // Step 1b: remove all nodes from boundary polygon
   boundary_polygon->nodes.clear();
   // Step 2: Remove all references to the boundary polygon from the Mesh's current list of nodes
   foreach (Node* node, nodes) {
     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 {
 private:
   SolveMesh(void);
 public:
   SolveMesh(Mesh *m_) {
     m = m_;
     kmax=0;
     kount=0;
     xp=0; yp=0; dxsav=0;
+  }
 protected:
   virtual void derivs(double x, double *y, double *dydx) {
     // set mesh with new values given by ODESolver
     // (we must do this, because only mesh knows the connections
     // between the variables)
     m->setValues(x,y);
     m->Derivatives(dydx);
     //cerr << "Calculated derivatives at " << x << "\n";
+  }
 private:
   Mesh *m;
   int kmax,kount;
   double *xp,**yp,dxsav;
   bool monitor_window;
 };
 void Mesh::ReactDiffuse(double delta_t) {
   // Set Lengths of Walls
   for_each ( walls.begin(), walls.end(),
 	     mem_fun( &Wall::SetLength ) );
   static SolveMesh *solver = new SolveMesh(this);
   int nok, nbad, nvar;
   double *ystart = getValues(&nvar);
   solver->odeint(ystart, nvar, getTime(), getTime() + delta_t,
 		 par.ode_accuracy, par.dt, 1e-10, &nok, &nbad);
   setTime(getTime()+delta_t);
   setValues(getTime(),ystart);
+}
 Vector Mesh::FirstConcMoment(int chem) {
   Vector moment;
   for (vector<Cell *>::const_iterator c=cells.begin(); c!=cells.end(); c++) {
     moment += (*c)->Chemical(chem) * (*c)->Centroid();
+  }
   return moment / (double)cells.size();
+}
 /*! This member function deletes all walls connected to two dead cells from the mesh.
   It should be called before the Cells are actually removed.
   If the cell is connect to one dead cell only, that reference is substituted for a reference
   to the boundary polygon.
 */
 void Mesh::DeleteLooseWalls(void) {
   list<Wall *>::iterator w=walls.begin();
   while (w!=walls.end()) {
     // if both cells of the wall are dead, remove the wall
     if ((*w)->C1()->DeadP() || (*w)->C2()->DeadP()) {
       if ((*w)->C1()->DeadP() && (*w)->C2()->DeadP()) {
 	delete *w;
 	w=walls.erase(w);
       } else {
 	if ((*w)->C1()->DeadP())
 	  (*w)->c1 = boundary_polygon;
 	else
 	  (*w)->c2 = boundary_polygon;
 	w++;
+      }
     } else {
       w++;
+    }
+  }
+}
 /*void Mesh::FitLeafToCanvas(double width, double height) {
   Vector bbll,bbur;
   BoundingBox(bbll,bbur);
   double scale_x = width/(bbur.x-bbll.x);
   double scale_y = height/(bbur.y-bbll.y);
   double factor = scale_x<scale_y ? scale_x:scale_y;
   Cell::SetMagnification(factor); // smallest of scale_x and scale_y
   double offset_x = (width/Cell::Magnification()-(bbur.x-bbll.x))/2.;
   double offset_y = (height/Cell::Magnification()-(bbur.y-bbll.y))/2.;
   Cell::setOffset(offset_x, offset_y);
   }*/
 void Mesh::CleanChemicals(const vector<double> &clean_chem) {
   if (clean_chem.size()!=(unsigned)Cell::NChem()) {
     throw "Run time error in Mesh::CleanChemicals: size of clean_chem should be equal to Cell::NChem()";
+  }
   for (vector<Cell *>::iterator c=cells.begin(); c!=cells.end(); c++) {
     for (int i=0;i<Cell::NChem();i++) {
       (*c)->SetChemical(i,clean_chem[i]);
+    }
     (*c)->SetNewChemToChem();
+  }
+}
 void Mesh::CleanTransporters(const vector<double> &clean_transporters) {
   if (clean_transporters.size()!=(unsigned)Cell::NChem()) {
     throw "Run time error in Mesh::CleanTransporters: size ofclean_transporters should be equal to Cell::NChem()";
+  }
   // clean transporters
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
     for (int i=0;i<Cell::NChem();i++) {
       (*w)->setTransporters1(i,clean_transporters[i]); (*w)->setNewTransporters1(i,clean_transporters[i]);
       (*w)->setTransporters2(i,clean_transporters[i]); (*w)->setNewTransporters2(i,clean_transporters[i]);
+    }
+  }
+}
 void Mesh::RandomizeChemicals(const vector<double> &max_chem, const vector<double> &max_transporters) {
   if (max_chem.size()!=(unsigned)Cell::NChem() || max_transporters.size()!=(unsigned)Cell::NChem()) {
     throw "Run time error in Mesh::CleanChemicals: size of max_chem and max_transporters should be equal to Cell::NChem()";
+  }
   for (vector<Cell *>::iterator c=cells.begin(); c!=cells.end(); c++) {
     for (int i=0;i<Cell::NChem();i++) {
       (*c)->SetChemical(i,max_chem[i]*RANDOM());
+    }
     (*c)->SetNewChemToChem();
+  }
   // randomize transporters
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
     for (int i=0;i<Cell::NChem();i++) {
       (*w)->setTransporters1(i,max_transporters[i] * RANDOM()); (*w)->setNewTransporters1(i, (*w)->Transporters1(i) );
       (*w)->setTransporters2(i,max_transporters[i] * RANDOM()); (*w)->setNewTransporters2(i, (*w)->Transporters1(i) );
+    }
+  }
+}
 //!\brief Calculates a vector with derivatives of all variables, which
 // we can pass to an ODESolver.
 void Mesh::Derivatives(double *derivs) {
   int nwalls = walls.size();
   int ncells = cells.size();
   int nchems = Cell::NChem();
   // two eqs per chemical for each walls, 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.
   int neqs = 2 * nwalls * nchems + ncells * nchems;
   //static double *derivs = 0;
   // derivs is allocated by RungeKutta class.
   for (int i=0;i<neqs;i++) {
     derivs[i]=0.;
+  }
   // Layout of derivatives: cells [ chem1 ... chem n]  walls [ [ w1(chem 1) ... w1(chem n) ] [ w2(chem 1) ... w2(chem n) ] ]
   int i=0;
   for (vector<Cell *>::iterator c=cells.begin(); c!=cells.end(); c++) {
     plugin->CellDynamics(*c, &(derivs[i]));
     i+=nchems;
+  }
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
     // (*wr)(*w, &(derivs[i]), &(derivs[i+nchems]));
     plugin->WallDynamics(*w,  &(derivs[i]), &(derivs[i+nchems]));
     // Transport function adds to derivatives of cell chemicals
     double *dchem_c1 = &(derivs[(*w)->c1->Index() * nchems]);
     double *dchem_c2 = &(derivs[(*w)->c2->Index() * nchems]);
     //plugin->CelltoCellTransport(*w, &(derivs[(*w)->c1->Index() * nchems]),
     //	  &(derivs[(*w)->c2->Index() * nchems]));
     // quick fix: dummy values to prevent end user from writing into outer space and causing a crash :-)
     // start here if you want to implement chemical input/output into environment over boundaries
     double dummy1, dummy2;
     if ((*w)->c1->Index()<0) { // tests if c1 is the boundary pol
       dchem_c1 = &dummy1;
+    }
     if ((*w)->c2->Index()<0) {
       dchem_c2 = &dummy2;
+    }
     plugin->CelltoCellTransport(*w, dchem_c1, dchem_c2);
     //(*tf)(*w, &(derivs[(*w)->c1->Index() * nchems]),
     //&(derivs[(*w)->c2->Index() * nchems] ) );
     i+=2*nchems;
+  }
+}
 void Mesh::setValues(double x, double *y) {
   //int nwalls = walls.size();
   //int ncells = cells.size();
   int nchems = Cell::NChem();
   // two eqs per chemical for each walls, 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.
   //int 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) ] ]
   int i=0;
   static int emit_count=0;
   const int stride = 100;
   for (vector<Cell *>::iterator c=cells.begin(); c!=cells.end(); c++) {
     for (int ch=0;ch<nchems;ch++) {
       (*c)->SetChemical(ch, y[i+ch]);
+    }
     if ( !(emit_count%stride)) {
       (*c)->EmitValues(x);
+    }
     i+=nchems;
+  }
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
     for (int ch=0;ch<nchems;ch++) {
       (*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
   for (int c=0; c<Cell::NChem(); c++) {
     circle.SetChemical(c, 0.);
+  }
+}
 /* finis */

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();
+    }
+  }
   inline Node &getNode(int i) {
     return *nodes[i];
+  }
   //double Diffusion(void);
   inline int size(void) {
     return cells.size();
+  }
   inline int nnodes(void) {
     return nodes.size();
+  }
   template<class Op> void LoopCells(Op f) {
     for (vector <Cell *>::iterator i=cells.begin();
 	 i!=cells.end();
 	 i++) {
       f(**i);
+    }
+  }
   template<class Op> void LoopWalls(Op f) {
     for (list <Wall *>::iterator i=walls.begin();
 	 i!=walls.end();
 	 i++) {
       f(**i);
+    }
+  }
   // if the amount of cells might increase, during looping, use this template
   template<class Op> void LoopCurrentCells(Op f) {
     vector<Cell *> current_cells = cells;
     for (vector <Cell *>::iterator i=current_cells.begin();
 	 i!=current_cells.end();
 	 i++) {
       f(**i);
+    }
+  }
   template<class Op> void LoopNodes(Op f) {
     for (vector<Node *>::iterator i=nodes.begin();
 	 i!=nodes.end();
 	 i++) {
       f(**i);
+    }
+  }
   template<class Op> void RandomlyLoopNodes(Op f) {
     MyUrand r(shuffled_nodes.size());
     random_shuffle(shuffled_nodes.begin(),shuffled_nodes.end(),r);
     for (vector<Node *>::const_iterator i=shuffled_nodes.begin();
 	 i!=shuffled_nodes.end();
 	 i++) {
       f(*shuffled_nodes[*i]);
+    }
+  }
   template<class Op> void RandomlyLoopCells(Op f) {
     MyUrand r(shuffled_cells.size());
     random_shuffle(shuffled_cells.begin(),shuffled_cells.end(),r);
     for (vector<Cell *>::const_iterator i=shuffled_cells.begin();
 	 i!=shuffled_cells.end();
 	 i++) {
       f(*shuffled_cells[*i]);
+    }
+  }
   template<class Op1, class Op2> void LoopCells(Op1 f, Op2 &g) {
     for (vector<Cell *>::iterator i=cells.begin();
 	 i!=cells.end();
 	 i++) {
       f(**i,g);
+    }
+  }
   template<class Op1, class Op2, class Op3> void LoopCells(Op1 f, Op2 &g, Op3 &h) {
     for (vector<Cell *>::iterator i=cells.begin();
 	 i!=cells.end();
 	 i++) {
       f(**i,g,h);
+    }
+  }
   void DoCellHouseKeeping(void) {
     vector<Cell *> current_cells = cells;
     for (vector<Cell *>::iterator i = current_cells.begin();
 	 i != current_cells.end();
 	 i ++) {
       plugin->CellHouseKeeping(*i);
       // Call functions of Cell that cannot be called from CellBase, including Division
       if ((*i)->flag_for_divide) {
 	if ((*i)->division_axis) {
 	  (*i)->DivideOverAxis(*(*i)->division_axis);
 	  delete (*i)->division_axis;
 	  (*i)->division_axis = 0;
 	} else {
 	  (*i)->Divide();
+	}
 	(*i)->flag_for_divide=false;
+      }
+    }
+  }
   // Apply "f" to cell i
   // i.e. this is an adapter which allows you to call a function
   // operating on Cell on its numeric index index
   template<class Op> void cell_index_adapter(Op f,int i) {
     f(cells[i]);
+  }
   double DisplaceNodes(void);
   void BoundingBox(Vector &LowerLeft, Vector &UpperRight);
   int NEqs(void) {     int nwalls = walls.size();
     int ncells =cells.size();
     int nchems = Cell::NChem();
     // two eqs per chemical for each walls, 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.
     int neqs = 2 * nwalls * nchems + ncells * nchems;
     return neqs;
+  }
   void IncreaseCellCapacityIfNecessary(void) {
     return;
     // cerr << "Entering Mesh::IncreaseCellCapacityIfNecessary \n";
     // make sure we always have enough space
     // to have each cell divide at least once
     //
     // Note that we must do this, because Cell::Divide pushes a new Cell
     // onto Mesh::cells. As a result, Mesh::cells might be relocated
     // if we are _within_ a Cell object: i.e. pointer "this" will be changed!!
     //
     // An alternative solution could be to make "Mesh::cells" a list,
     // but this won't work because we need random access for
     // the Monte Carlo algorithm.
     if (2*cells.size()>cells.capacity()) {
       cerr << "Increasing capacity to "  << 2*cells.capacity() << endl;
       cerr << "Current capacity is " << cells.capacity() << endl;
       cells.reserve(cells.capacity()*2);
+    }
+  }
   void ReserveMoreCells(int n) {
     if (nodes.size()+n>nodes.capacity()) {
       nodes.reserve(size()+n);
+    }
+  }
   double Area(void);
   double MeanArea(void) {
     double sum=0.;
     for (vector<Cell *>::const_iterator i=cells.begin();
 	 i!=cells.end();
 	 i++) {
       sum+=(*i)->Area();
+    }
     return sum/(double)NCells();
+  }
   void SetBaseArea(void);
   int NCells(void) const {
     return cells.size();
+  }
   inline int NNodes(void) const {
     return nodes.size();
+  }
   void PrintQueue(ostream &os) {
     while (!node_insertion_queue.empty()) {
       os << node_insertion_queue.front() << endl;
       node_insertion_queue.pop();
+    }
+  }
   void InsertNodes(void) {
     // insert the nodes in the insertion queue
     while (!node_insertion_queue.empty()) {
       //cerr << node_insertion_queue.front() << endl;
       InsertNode(node_insertion_queue.front());
       node_insertion_queue.pop();
+    }
+  }
   void Clear();
   void ReactDiffuse( double delta_t = 1 );
   double SumChemical(int ch);
   void SetChemical(int ch, double value) {
     for (vector<Cell *>::iterator c=cells.begin();
 	 c!=cells.end();
 	 c++) {
       (*c)->chem[ch]=value;
+    }
+  }
   // used for interacing with ODE-solvers (e.g. NRCRungeKutta)
   void setValues(double x, double *y);
   double *getValues(int *neqs);
   void Derivatives(double *derivs);
 #ifdef QTGRAPHICS
   inline void DrawBoundary(QGraphicsScene *c) {
     boundary_polygon->Draw(c);
+  }
   void DrawNodes(QGraphicsScene *c) const;
 #endif
   double max_chem;
   void XMLSave(const char *docname, xmlNode *settings=0) const;
   void XMLRead(const char *docname, xmlNode **settings=0, bool geometry = true, bool pars = true, bool simtime = true);
   void XMLReadPars(const xmlNode * root_node);
   void XMLReadGeometry(const xmlNode *root_node);
   void XMLReadSimtime(const xmlNode *root_node);
   void XMLReadNodes(xmlNode *cur);
   void XMLReadCells(xmlNode *cur);
   void XMLParseTree(const xmlNode * root_node);
   void XMLReadWalls(xmlNode *cur, vector<Wall *> *tmp_cells);
   void XMLReadWallsToCells(xmlNode *root, vector<Wall *> *tmp_walls);
   void XMLReadNodeSets(xmlNode *root);
   void XMLReadNodeSetsToNodes(xmlNode *root);
   void PerturbChem(int chemnum, double range);
   void CleanUpCellNodeLists(void);
   void CleanUpWalls(void);
   void CutAwayBelowLine( Vector startpoint, Vector endpoint );
   void CutAwaySAM(void);
   void RepairBoundaryPolygon(void);
   void Rotate(double angle, Vector center);
   void PrintWallList( void );
   void TestIllegalWalls(void);
   Vector FirstConcMoment(int chem);
   inline Vector Centroid(void) {
     return boundary_polygon->Centroid();
+  }
   inline Vector Offset(void) {
     return boundary_polygon->Offset();
+  }
   inline double Factor(void) {
     return boundary_polygon->Factor();
+  }
   void DeleteLooseWalls(void);
   void FitLeafToCanvas(double width, double height);
   void AddNodeSet(NodeSet *node_set) {
     node_sets.push_back(node_set);
+  }
   void CleanChemicals(const vector<double> &clean_chem);
   void CleanTransporters(const vector<double> &clean_transporters);
   void RandomizeChemicals(const vector<double> &max_chem, const vector<double> &max_transporters);
   inline double getTime(void) const { return time; }
   string getTimeHours(void) const;
   inline void setTime(double t) { time = t; }
   double CalcProtCellsWalls(int ch) const;
   void SettoInitVals(void);
   QVector<qreal> VertexAngles(void);
   QVector< QPair<qreal,int> > VertexAnglesValues(void);
   void SetSimPlugin(SimPluginInterface *new_plugin) {
     plugin=new_plugin;
+  }
   QString ModelID(void) { return plugin?plugin->ModelID():QString("undefined"); }
   void StandardInit(void);
   Node* findNextBoundaryNode(Node*);
  private:
   // Data members
   vector<Cell *> cells;
   vector<Node *> nodes;
   list<Wall *> walls; // we need to erase elements from this container frequently, hence a list.
  public:
   vector<NodeSet *> node_sets;
  private:
   vector<Node *> shuffled_nodes;
   vector<Cell *> shuffled_cells;

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!");
+  }
   QStringList modelnames=pluginDir.entryList(QDir::Files);
   if (modelnames.empty()) {
     MyWarning::error("Model %s not found - hint: do not include path in filename.",model);
+  }
   foreach (QString fileName, modelnames){
     QPluginLoader loader(pluginDir.absoluteFilePath(fileName));
     if (SimPluginInterface *plugin =
 	qobject_cast<SimPluginInterface *>(loader.instance())) {
       models.append(plugin);
       //MyWarning::warning("Successfully loaded model %s",fileName.toStdString().c_str());
     } else {
       MyWarning::warning("Could not load plugin %s",fileName.toStdString().c_str());
+    }
+  }
+}
 void ModelCatalogue::InstallFirstModel() {
   InstallModel(models[0]);
+}
 void ModelCatalogue::PopulateModelMenu() {
   foreach (SimPluginInterface *model, models) {
     QAction *modelaction = new QAction(model->ModelID(), mainwin);
     QVariant data;
     data.setValue(model);
     modelaction->setData(data);
     mainwin->modelmenu->addAction(modelaction);
+  }
   connect(mainwin->modelmenu, SIGNAL(triggered(QAction *)), this, SLOT(InstallModel(QAction *)) );
+}
 void ModelCatalogue::InstallModel(QAction *modelaction) {
   QVariant data = modelaction->data();
   SimPluginInterface *model = data.value<SimPluginInterface *>();
   cerr << "You chose model " << model->ModelID().toStdString() << "!\n";
   mesh->Clean();
   InstallModel(model);
+}
 void ModelCatalogue::InstallModel(SimPluginInterface *plugin) {
   // make sure both main and plugin use the same static datamembers (ncells, nchems...)
   plugin->SetCellsStaticDatamembers(CellBase::GetStaticDataMemberPointer());
   mesh->SetSimPlugin(plugin);
   Cell::SetNChem(plugin->NChem());
   plugin->SetParameters(&par);
   if (mainwin) {
     mainwin->RefreshInfoBar();
     mainwin->Init(0);
+  }
+}

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;
   boundary = src.boundary;
   sam=src.sam;
   dead = src.dead;
+}
 Cell &Node::getCell(const Neighbor &i)
+{
   return *i.getCell(); // use accessor!
+}
 ostream &Node::print(ostream &os) const {
   if (!dead)
     os << "Node ";
   else
     os << "DEAD NODE ";
   os  << index << "[ {" << x << ", " << y << ", " << z << "}: {";
   os << "Neighbors = { ";
   for (list<Neighbor>::const_iterator i =  owners.begin(); i!=owners.end(); i++) {
     os << " {" << i->cell->Index() << " " << i->nb1->Index() << " " << i->nb2->Index() << "} ";
+  }
   os << " } " << endl;
   return os;
+}
 #ifdef QTGRAPHICS
 void Node::DrawIndex(QGraphicsScene *c) const {
   //return DrawOwners(c);
   stringstream text;
   text << index;
   QGraphicsSimpleTextItem *number = new QGraphicsSimpleTextItem ( QString (text.str().c_str()), 0, c );
   number->setFont( QFont( "Helvetica", par.nodenumsize, QFont::Bold) );
   number->setPen( QPen (par.textcolor) );
   number->setZValue(20);
   number->show();
   Vector offs=Cell::Offset();
   number -> setPos(
 		   ((offs.x+x)*Cell::Factor()),
 		   ((offs.y+y)*Cell::Factor()) );
+}
 void Node::DrawOwners(QGraphicsScene *c) const {
   stringstream text;
   text << owners.size();
   QGraphicsSimpleTextItem *number = new QGraphicsSimpleTextItem ( QString (text.str().c_str()), 0, c );
   number->setFont( QFont( "Helvetica", par.nodenumsize, QFont::Bold) );
   number->setPen( QPen(par.textcolor) );
   number->setZValue(20);
   number->show();
   Vector offs=Cell::Offset();
   number ->setPos(((offs.x+x)*Cell::Factor()),
 		  ((offs.y+y)*Cell::Factor()) );
+}
 QVector<qreal> Node::NeighbourAngles(void)
+{
   QVector<qreal> angles;
   for (list<Neighbor>::iterator i=owners.begin(); i!=owners.end(); i++) {
     Vector v1 = (*this - *i->nb1).Normalised();
     Vector v2 = (*this - *i->nb2).Normalised();
     double angle = v1.SignedAngle(v2);
     if (angle<0) {
       //cerr << "Changing sign of angle " << angle << endl;
       angle = angle + 2*Pi;
+    }
     angles.push_back(angle);
     //cerr << "Cell " << i->cell->Index() << ": " <<  v1 << " and " << v2
     //     << ": angle = " << angles.back() << ", " << v1.Angle(v2) << endl;
+  }
   double sum=0.;
   for (QVector<qreal>::iterator i=angles.begin(); i!=angles.end(); i++) {
     sum+=*i;
+  }
   //cerr << "Angle sum = " << sum << endl;
   // Check if the summed angle is different from 2 Pi
   if (fabs(sum-(2*Pi))>0.0001) {
     MyWarning::warning("sum = %f",sum);
+  }
   return angles;
+}
 #endif
 ostream &operator<<(ostream &os, const Node &n) {
   n.print(os);
   return os;
+}
 /* finis */

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

0 comments (0 inline, 0 general)