EI/VirtualLeaf Changeset - 311dea91a9b6 · Centrum Wiskunde & Informatica (CWI)

Changeset - 311dea91a9b6

Parent rev.

Child rev.

[Not reviewed]

Merge default

1 23 19

Michael Guravage - 15 years ago 2010-06-04 16:05:21
michael.guravage@cwi.nl

Merged Roeland's latest changes with my project file changes (16:3f0977faba37).

--
user: Michael Guravage <michael.guravage@cwi.nl>
branch merge
branch 'default'
changed src/Makefile
changed src/TutorialCode/Tutorial0/mymodel.cpp
changed src/TutorialCode/Tutorial0/mymodel.h
changed src/TutorialCode/Tutorial0/mymodel.pro
changed src/TutorialCode/Tutorial1/mymodel.cpp
changed src/TutorialCode/Tutorial1/mymodel.h
changed src/TutorialCode/Tutorial1/mymodel.pro
changed src/TutorialCode/Tutorial2/mymodel.cpp
changed src/TutorialCode/Tutorial2/mymodel.h
changed src/TutorialCode/Tutorial2/mymodel.pro
changed src/TutorialCode/Tutorial3/mymodel.cpp
changed src/TutorialCode/Tutorial3/mymodel.h
changed src/TutorialCode/Tutorial3/mymodel.pro
changed src/TutorialCode/Tutorial4/mymodel.cpp
changed src/TutorialCode/Tutorial4/mymodel.h
changed src/TutorialCode/Tutorial4/mymodel.pro
changed src/TutorialCode/Tutorial5/mymodel.cpp
changed src/TutorialCode/Tutorial5/mymodel.h
changed src/TutorialCode/Tutorial5/mymodel.pro
changed src/VirtualLeaf.pro
changed src/VirtualLeafpar.tmpl
changed src/build_models/Makefile
changed src/build_models/auxingrowthplugin.cpp
changed src/build_models/auxingrowthplugin.h
changed src/build_models/leafplugin.cpp
changed src/build_models/leafplugin.h
changed src/build_models/meinhardtplugin.cpp
changed src/build_models/meinhardtplugin.h
changed src/build_models/plugin_auxingrowth.pro
changed src/build_models/plugin_leaf.pro
changed src/build_models/plugin_meinhardt.pro
changed src/build_models/plugin_test.pro
changed src/build_models/testplugin.cpp
changed src/build_models/testplugin.h
changed src/build_models/translate_plugin.pl
changed src/cell.cpp
changed src/cellbase.h
changed src/libplugin.pro
changed src/mesh.cpp
changed src/mesh.h
changed src/modelcatalogue.cpp
changed src/simplugin.h
removed src/build_models/simplugin.h

42 files changed with 1422 insertions and 207 deletions:

src/Makefile

src/TutorialCode/Tutorial0/mymodel.cpp

src/TutorialCode/Tutorial0/mymodel.h

src/TutorialCode/Tutorial0/mymodel.pro

src/TutorialCode/Tutorial1/mymodel.cpp

src/TutorialCode/Tutorial1/mymodel.h

src/TutorialCode/Tutorial1/mymodel.pro

src/TutorialCode/Tutorial2/mymodel.cpp

src/TutorialCode/Tutorial2/mymodel.h

src/TutorialCode/Tutorial2/mymodel.pro

src/TutorialCode/Tutorial3/mymodel.cpp

src/TutorialCode/Tutorial3/mymodel.h

src/TutorialCode/Tutorial3/mymodel.pro

src/TutorialCode/Tutorial4/mymodel.cpp

src/TutorialCode/Tutorial4/mymodel.h

src/TutorialCode/Tutorial4/mymodel.pro

src/TutorialCode/Tutorial5/mymodel.cpp

120

src/TutorialCode/Tutorial5/mymodel.h

src/TutorialCode/Tutorial5/mymodel.pro

src/VirtualLeaf.pro

src/VirtualLeafpar.tmpl

src/build_models/Makefile

src/build_models/auxingrowthplugin.cpp

src/build_models/auxingrowthplugin.h

src/build_models/leafplugin.cpp

src/build_models/leafplugin.h

src/build_models/meinhardtplugin.cpp

src/build_models/meinhardtplugin.h

src/build_models/plugin_auxingrowth.pro

src/build_models/plugin_leaf.pro

src/build_models/plugin_meinhardt.pro

src/build_models/plugin_test.pro

src/build_models/simplugin.h

src/build_models/testplugin.cpp

src/build_models/testplugin.h

src/build_models/translate_plugin.pl

src/cell.cpp

src/cellbase.h

src/libplugin.pro

src/mesh.h

src/modelcatalogue.cpp

src/simplugin.h

0 comments (0 inline, 0 general)

src/Makefile

➞

Show inline comments

 # $Id$
 QMAKE = qmake
 all: VirtualLeaf libplugin plugins
 VirtualLeaf: Makefile.VirtualLeaf
 	make -f Makefile.VirtualLeaf
 Makefile.VirtualLeaf: VirtualLeaf.pro
-	qmake -makefile -o $@ $<
+	$(QMAKE) -makefile -o $@ $<
 libplugin: Makefile.libplugin
 	make -f Makefile.libplugin
 Makefile.libplugin: libplugin.pro
-	qmake -makefile -o $@ $<
+	$(QMAKE) -makefile -o $@ $<
 plugins:
 	make -C build_models
 clean:
 	make -f Makefile.libplugin clean
 	make -f Makefile.VirtualLeaf clean
 	make -C build_models clean
 #finis

src/TutorialCode/Tutorial0/mymodel.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
+ *
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "mymodel.h"
 static const std::string _module_id("$Id$");
 QString MyModel::ModelID(void) {
   // specify the name of your model here
   return QString( "My first model in VirtualLeaf" );
+}
 // return the number of chemicals your model uses
 int MyModel::NChem(void) { return 0; }
 // To be executed after cell division
 void MyModel::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
   // rules to be executed after cell division go here
   // (e.g., cell differentiation rules)
+}
 void MyModel::SetCellColor(CellBase *c, QColor *color) {
   // add cell coloring rules here
+}
 void MyModel::CellHouseKeeping(CellBase *c) {
   // add cell behavioral rules here
+}
 void MyModel::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
   // add biochemical transport rules here
+}
 void MyModel::WallDynamics(Wall *w, double *dw1, double *dw2) {
   // add biochemical networks for reactions occuring at walls here
+}
 void MyModel::CellDynamics(CellBase *c, double *dchem) {
   // add biochemical networks for intracellular reactions here
+}
 Q_EXPORT_PLUGIN2(mymodel, MyModel)

src/TutorialCode/Tutorial0/mymodel.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  *  $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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "simplugin.h"
 class MyModel : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void);
 	// Executed after the cellular mechanics steps have equillibrized
 	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
 	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
 	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void);
 };

src/TutorialCode/Tutorial0/mymodel.pro

➞

Show inline comments

@@ new file 100644 @@
+#
 # $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.
+#
 TARGET = mymodel
 VLEAFHOME = ../../..
 CONFIG += release
 CONFIG -= debug
 CONFIG += plugin
 BINDIR = $${VLEAFHOME}/bin
 LIBDIR = $${VLEAFHOME}/lib
 INCDIR = $${VLEAFHOME}/src
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = $${BINDIR}/models
 HEADERS = $${TARGET}.h
 INCLUDEPATH += $${INCDIR}
 QMAKE_CXXFLAGS += -fexceptions #-I$${INCDIR}
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QT += qt3support
 SOURCES = $${TARGET}.cpp
 TEMPLATE = lib
 unix {
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finish

src/TutorialCode/Tutorial1/mymodel.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
+ *
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "mymodel.h"
 static const std::string _module_id("$Id$");
 QString MyModel::ModelID(void) {
   // specify the name of your model here
   return QString( "Cell growth" );
+}
 // return the number of chemicals your model uses
 int MyModel::NChem(void) { return 0; }
 // To be executed after cell division
 void MyModel::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
   // rules to be executed after cell division go here
   // (e.g., cell differentiation rules)
+}
 void MyModel::SetCellColor(CellBase *c, QColor *color) {
   // add cell coloring rules here
+}
 void MyModel::CellHouseKeeping(CellBase *c) {
   // add cell behavioral rules here
 	c->EnlargeTargetArea(par->cell_expansion_rate);
+}
 void MyModel::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
   // add biochemical transport rules here
+}
 void MyModel::WallDynamics(Wall *w, double *dw1, double *dw2) {
   // add biochemical networks for reactions occuring at walls here
+}
 void MyModel::CellDynamics(CellBase *c, double *dchem) {
   // add biochemical networks for intracellular reactions here
+}
 Q_EXPORT_PLUGIN2(mymodel, MyModel)

src/TutorialCode/Tutorial1/mymodel.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  *  $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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "simplugin.h"
 class MyModel : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void);
 	// Executed after the cellular mechanics steps have equillibrized
 	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
 	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
 	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void);
 };

src/TutorialCode/Tutorial1/mymodel.pro

➞

Show inline comments

@@ new file 100644 @@
+#
 # $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.
+#
 TARGET = mymodel
 VLEAFHOME = ../../..
 CONFIG += release
 CONFIG -= debug
 CONFIG += plugin
 BINDIR = $${VLEAFHOME}/bin
 LIBDIR = $${VLEAFHOME}/lib
 INCDIR = $${VLEAFHOME}/src
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = $${BINDIR}/models
 HEADERS = $${TARGET}.h
 INCLUDEPATH += $${INCDIR}
 QMAKE_CXXFLAGS += -fexceptions #-I$${INCDIR}
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QT += qt3support
 SOURCES = $${TARGET}.cpp
 TEMPLATE = lib
 unix {
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finish

src/TutorialCode/Tutorial2/mymodel.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
+ *
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "mymodel.h"
 static const std::string _module_id("$Id$");
 QString MyModel::ModelID(void) {
   // specify the name of your model here
   return QString( "Cell growth and cell division" );
+}
 // return the number of chemicals your model uses
 int MyModel::NChem(void) { return 0; }
 // To be executed after cell division
 void MyModel::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
   // rules to be executed after cell division go here
   // (e.g., cell differentiation rules)
+}
 void MyModel::SetCellColor(CellBase *c, QColor *color) {
   // add cell coloring rules here
+}
 void MyModel::CellHouseKeeping(CellBase *c) {
   // add cell behavioral rules here
 	c->EnlargeTargetArea(par->cell_expansion_rate);
 	if (c->Area() > par->rel_cell_div_threshold * c->BaseArea()) {
 		c->Divide();
+	}
+}
 void MyModel::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
   // add biochemical transport rules here
+}
 void MyModel::WallDynamics(Wall *w, double *dw1, double *dw2) {
   // add biochemical networks for reactions occuring at walls here
+}
 void MyModel::CellDynamics(CellBase *c, double *dchem) {
   // add biochemical networks for intracellular reactions here
+}
 Q_EXPORT_PLUGIN2(mymodel, MyModel)

src/TutorialCode/Tutorial2/mymodel.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  *  $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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "simplugin.h"
 class MyModel : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void);
 	// Executed after the cellular mechanics steps have equillibrized
 	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
 	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
 	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void);
 };

src/TutorialCode/Tutorial2/mymodel.pro

➞

Show inline comments

@@ new file 100644 @@
+#
 # $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.
+#
 TARGET = mymodel
 VLEAFHOME = ../../..
 CONFIG += release
 CONFIG -= debug
 CONFIG += plugin
 BINDIR = $${VLEAFHOME}/bin
 LIBDIR = $${VLEAFHOME}/lib
 INCDIR = $${VLEAFHOME}/src
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = $${BINDIR}/models
 HEADERS = $${TARGET}.h
 INCLUDEPATH += $${INCDIR}
 QMAKE_CXXFLAGS += -fexceptions #-I$${INCDIR}
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QT += qt3support
 SOURCES = $${TARGET}.cpp
 TEMPLATE = lib
 unix {
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finish

src/TutorialCode/Tutorial3/mymodel.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
+ *
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "mymodel.h"
 static const std::string _module_id("$Id$");
 QString MyModel::ModelID(void) {
   // specify the name of your model here
   return QString( "Cell growth and cell division" );
+}
 // return the number of chemicals your model uses
 int MyModel::NChem(void) { return 0; }
 // To be executed after cell division
 void MyModel::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
   // rules to be executed after cell division go here
   // (e.g., cell differentiation rules)
+}
 void MyModel::SetCellColor(CellBase *c, QColor *color) {
   // add cell coloring rules here
+}
 void MyModel::CellHouseKeeping(CellBase *c) {
   // add cell behavioral rules here
 	c->EnlargeTargetArea(par->cell_expansion_rate);
 	if (c->Area() > par->rel_cell_div_threshold * c->BaseArea()) {
 		c->DivideOverAxis(Vector(1,0,0));
+	}
+}
 void MyModel::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
   // add biochemical transport rules here
+}
 void MyModel::WallDynamics(Wall *w, double *dw1, double *dw2) {
   // add biochemical networks for reactions occuring at walls here
+}
 void MyModel::CellDynamics(CellBase *c, double *dchem) {
   // add biochemical networks for intracellular reactions here
+}
 Q_EXPORT_PLUGIN2(mymodel, MyModel)

src/TutorialCode/Tutorial3/mymodel.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  *  $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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "simplugin.h"
 class MyModel : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void);
 	// Executed after the cellular mechanics steps have equillibrized
 	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
 	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
 	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void);
 };

src/TutorialCode/Tutorial3/mymodel.pro

➞

Show inline comments

@@ new file 100644 @@
+#
 # $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.
+#
 TARGET = mymodel
 VLEAFHOME = ../../..
 CONFIG += release
 CONFIG -= debug
 CONFIG += plugin
 BINDIR = $${VLEAFHOME}/bin
 LIBDIR = $${VLEAFHOME}/lib
 INCDIR = $${VLEAFHOME}/src
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = $${BINDIR}/models
 HEADERS = $${TARGET}.h
 INCLUDEPATH += $${INCDIR}
 QMAKE_CXXFLAGS += -fexceptions #-I$${INCDIR}
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QT += qt3support
 SOURCES = $${TARGET}.cpp
 TEMPLATE = lib
 unix {
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finish

src/TutorialCode/Tutorial4/mymodel.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
+ *
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "mymodel.h"
 static const std::string _module_id("$Id$");
 QString MyModel::ModelID(void) {
   // specify the name of your model here
   return QString( "Growth, division, coloring" );
+}
 // return the number of chemicals your model uses
 int MyModel::NChem(void) { return 0; }
 // To be executed after cell division
 void MyModel::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
   // rules to be executed after cell division go here
   // (e.g., cell differentiation rules)
+}
 void MyModel::SetCellColor(CellBase *c, QColor *color) {
   // add cell coloring rules here
 	if (c->Area()/c->BaseArea()>1.8) { color->setNamedColor("blue"); }
 	else { color->setNamedColor("green"); }
+}
 void MyModel::CellHouseKeeping(CellBase *c) {
   // add cell behavioral rules here
 	c->EnlargeTargetArea(par->cell_expansion_rate);
 	if (c->Area() > par->rel_cell_div_threshold * c->BaseArea()) {
 		c->Divide();
+	}
+}
 void MyModel::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
   // add biochemical transport rules here
+}
 void MyModel::WallDynamics(Wall *w, double *dw1, double *dw2) {
   // add biochemical networks for reactions occuring at walls here
+}
 void MyModel::CellDynamics(CellBase *c, double *dchem) {
   // add biochemical networks for intracellular reactions here
+}
 Q_EXPORT_PLUGIN2(mymodel, MyModel)

src/TutorialCode/Tutorial4/mymodel.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  *  $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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "simplugin.h"
 class MyModel : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void);
 	// Executed after the cellular mechanics steps have equillibrized
 	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
 	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
 	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void);
 };

src/TutorialCode/Tutorial4/mymodel.pro

➞

Show inline comments

@@ new file 100644 @@
+#
 # $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.
+#
 TARGET = mymodel
 VLEAFHOME = ../../..
 CONFIG += release
 CONFIG -= debug
 CONFIG += plugin
 BINDIR = $${VLEAFHOME}/bin
 LIBDIR = $${VLEAFHOME}/lib
 INCDIR = $${VLEAFHOME}/src
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = $${BINDIR}/models
 HEADERS = $${TARGET}.h
 INCLUDEPATH += $${INCDIR}
 QMAKE_CXXFLAGS += -fexceptions #-I$${INCDIR}
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QT += qt3support
 SOURCES = $${TARGET}.cpp
 TEMPLATE = lib
 unix {
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finish

src/TutorialCode/Tutorial5/mymodel.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
+ *
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "mymodel.h"
 static const std::string _module_id("$Id$");
 QString MyModel::ModelID(void) {
   // specify the name of your model here
   return QString( "Growth hormones" );
+}
 // return the number of chemicals your model uses
 int MyModel::NChem(void) { return 1; }
 // To be executed after cell division
 void MyModel::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
   // rules to be executed after cell division go here
   // (e.g., cell differentiation rules)
 	// set one cell to source after first division
 	if (CellBase::NCells()==2) {
 		daughter1->SetCellType(1);
 		daughter2->SetCellType(0);
+	}
 	// if a source cells has divided, one of the daughters becomes the new source
 	if (daughter1->CellType()==1) {
 		// if both cells are at the tissue perimeter, choose at random
 		if (daughter1->AtBoundaryP() && daughter2->AtBoundaryP()) {
 			if (qrand()%2){
 				daughter1->SetCellType(1);
 				daughter2->SetCellType(0);
 			} else {
 				daughter1->SetCellType(0);
 				daughter2->SetCellType(1);
+			}
 		} else {
 			// otherwise choose the one that is still at the perimeter
 			if (daughter1->AtBoundaryP()) {
 				daughter1->SetCellType(1);
 				daughter2->SetCellType(0);
 			} else {
 				daughter1->SetCellType(0);
 				daughter2->SetCellType(1);
+			}
+		}
+	}
+}
 void MyModel::SetCellColor(CellBase *c, QColor *color) {
   // add cell coloring rules here
 	// white: high concentration of growth hormone, black low concentration
 	double val = c->Chemical(0)/(1.+c->Chemical(0));
 	color->setRgbF(val, val, val);
+}
 void MyModel::CellHouseKeeping(CellBase *c) {
   // add cell behavioral rules here
 	if (CellBase::NCells()==1)
 		// first cell expands unconditionally
 		c->EnlargeTargetArea(par->cell_expansion_rate);
 	else
 		c->EnlargeTargetArea(c->Chemical(0)*par->cell_expansion_rate);
 	if (c->Area() > par->rel_cell_div_threshold * c->BaseArea()) {
 		c->Divide();
+	}
+}
 void MyModel::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
   // add biochemical transport rules here
 	double phi = w->Length() * par->D[0] * ( w->C2()->Chemical(0) - w->C1()->Chemical(0) );
 	dchem_c1[0]+=phi;
 	dchem_c2[0]-=phi;
+}
 void MyModel::WallDynamics(Wall *w, double *dw1, double *dw2) {
   // add biochemical networks for reactions occuring at walls here
+}
 void MyModel::CellDynamics(CellBase *c, double *dchem) {
   // add biochemical networks for intracellular reactions here
 	if (c->CellType()==1) {
 		dchem[0] = par->leaf_tip_source;
+	}
+}
 Q_EXPORT_PLUGIN2(mymodel, MyModel)

src/TutorialCode/Tutorial5/mymodel.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  *  $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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "simplugin.h"
 class MyModel : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void);
 	// Executed after the cellular mechanics steps have equillibrized
 	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
 	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
 	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void);
 };

src/TutorialCode/Tutorial5/mymodel.pro

➞

Show inline comments

@@ new file 100644 @@
+#
 # $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.
+#
 TARGET = mymodel
 VLEAFHOME = ../../..
 CONFIG += release
 CONFIG -= debug
 CONFIG += plugin
 BINDIR = $${VLEAFHOME}/bin
 LIBDIR = $${VLEAFHOME}/lib
 INCDIR = $${VLEAFHOME}/src
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
 DESTDIR = $${BINDIR}/models
 HEADERS = $${TARGET}.h
 INCLUDEPATH += $${INCDIR}
 QMAKE_CXXFLAGS += -fexceptions #-I$${INCDIR}
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QT += qt3support
 SOURCES = $${TARGET}.cpp
 TEMPLATE = lib
 unix {
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finish

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_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
 PERLDIR = ./perl
 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 {
  system(WHERE /Q perl && IF errorlevel 0 (DEL parameter.cpp parameter.h pardialog.cpp pardialog.h)
  system(WHERE /Q perl && IF errorlevel 0 (perl $$PERLDIR\make_parameter_source.pl $$PARTMPL)
  system(WHERE /Q perl && IF errorlevel 0 (perl $$PERLDIR\make_pardialog_source.pl $$PARTMPL)
 #system(WHERE /Q perl && IF errorlevel 0 (perl $$PERLDIR\make_xmlwritecode.pl -h $$REACTIONS)
  CONFIG += console
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  system(DEL parameter.cpp parameter.h)
  GRAPHICS = qt
  RC_FILE = VirtualLeaf.rc
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
  QMAKE_POST_LINK = "\
   C:\Bin\cp release\VirtualLeaf.exe \
   C:\Qt\4.5.3\bin\Qt3Support4.dll \
   C:\Qt\4.5.3\bin\QtGui4.dll \
   C:\Qt\4.5.3\bin\QtSql4.dll \
   C:\Qt\4.5.3\bin\QtXml4.dll \
   C:\Qt\4.5.3\bin\QtCore4.dll \
   C:\Qt\4.5.3\bin\QtNetwork4.dll \
   C:\Qt\4.5.3\bin\QtSvg4.dll \
   C:\bin\iconv.dll \
   C:\bin\libxml2.dll \
   C:\bin\zlib1.dll \
   C:\MinGW\bin\mingwm10.dll \
   $${DESTDIR}"
  LIBS += -L$${LIBXML2DIR}\lib -lxml2 -L$${LIBICONVDIR}\lib -L$${LIBZDIR}\lib  -lz -lm -lwsock32 -liconv
+}
 # Application icons
 macx {
  ICON = leaficon.icns
  # make sure that the executable can find the libqwt share library
  QMAKE_POST_LINK = "mkdir $${DESTDIR}/$${TARGET}.app/Contents/Frameworks; \
   cp /usr/local/qwt/lib/libqwt.dylib $${DESTDIR}/$${TARGET}.app/Contents/Frameworks/.; \
   #install_name_tool -change libqwt.5.dylib $$QWTDIR/lib/libqwt.dylib $${DESTDIR}/$${TARGET}.app/Contents/MacOS/$${TARGET}; \
   install_name_tool -id @executable_path/../Frameworks/libqwt.dylib $${DESTDIR}/$${TARGET}.app/Contents/Frameworks/libqwt.dylib; \
   install_name_tool -change libqwt.5.dylib @executable_path/../Frameworks/libqwt.dylib $${DESTDIR}/$${TARGET}.app/Contents/MacOS/$${TARGET};\
   cp leaficon.icns $${DESTDIR}/$${TARGET}.app; "
+}
 macx:release {
  LIBS+= -dead_strip
+}
 unix {
  system(if `which perl > /dev/null 2>&1` ; then rm -f parameter.cpp parameter.h pardialog.cpp pardialog.h; fi)
  system(if `which perl > /dev/null 2>&1` ; then perl $$PERLDIR/make_parameter_source.pl $$PARTMPL; fi)
  system(if `which perl > /dev/null 2>&1` ; then perl $$PERLDIR/make_pardialog_source.pl $$PARTMPL; fi)
 #system(if `which perl > /dev/null 2>&1` ; then perl $$PERLDIR/make_xmlwritecode.pl -h $$REACTIONS; fi)
  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 \
  canvas.h \
  cellbase.h \
  cell.h \
  cellitem.h \
  forwardeuler.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 \
  canvas.cpp \
  cellbase.cpp \
  cell.cpp \
  cellitem.cpp \
  forwardeuler.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 \
  xmlwritecode.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
+}
 # finis

src/VirtualLeafpar.tmpl

➞

Show inline comments

 title = Parameter values for The Virtual Leaf / title
 label = <b>Visualization</b> / label
 arrowcolor = white / string
 arrowsize = 100 / double
 textcolor = red / string
 cellnumsize = 1 / int
 nodenumsize = 1 / int
 node_mag = 1.0 / double
 outlinewidth = 1.0 / double
 cell_outline_color = forestgreen / string
-resize_stride = 10 / int
+resize_stride = 0 / int
 label = / label
 label = <b>Cell mechanics</b> / label
 T = 1.0 / double
 lambda_length = 100. / double
 lambda_celllength = 0. / double
 target_length = 60. / double
 cell_expansion_rate = 1. / double
 cell_div_expansion_rate = 0. / double
 auxin_dependent_growth = true / bool
 ode_accuracy = 1e-4 / double
 mc_stepsize = 0.4 / double
 mc_cell_stepsize = 0.2 / double
 energy_threshold = 1000. / double
 bend_lambda = 0. / double
 alignment_lambda = 0. / double
 rel_cell_div_threshold = 2. / double
 rel_perimeter_stiffness = 2 / double
 collapse_node_threshold = 0.05 / double
 morphogen_div_threshold = 0.2 / double
 morphogen_expansion_threshold = 0.01 / double
 copy_wall = true / bool
 label = / label
 label = <b>Auxin transport and PIN1 dynamics</b> / label
 source = 0. / double
 D = 0., 0.0, 0.0, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0. / doublelist
 initval = 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0. / doublelist
 k1 = 1. / double
 k2 = 0.3 / double
 r = 1. / double
 kr = 1. / double
 #k3 = 1 / double
 #k4 = 0.3 / double
 km = 1. / double
 Pi_tot = 1. / double
 transport = 0.036 / double
 ka = 1 / double
 # d = 1e-06 / double
 # e = 0.01 / double
 # f = 10 / double
 pin_prod = 0.001 / double
 pin_prod_in_epidermis = 0.1 / double
 pin_breakdown = 0.001 / double
 pin_breakdown_internal = 0.001 / double
 aux1prod = 0.001 / double
 aux1prodmeso = 0. / double
 aux1decay = 0.001 / double
 aux1decaymeso = 0.1 / double
 aux1transport = 0.036 / double
 aux_cons = 0. / double
 aux_breakdown = 0. / double
 kaux1 = 1 / double
 kap = 1 / double
 leaf_tip_source = 0.001 / double
 sam_efflux = 0.0001 / double
 sam_auxin = 10. / double
 # gf_prod = 1e-3 / double
 # gf_decay = 1e-3 / double
 sam_auxin_breakdown = 0 / double
 #label = / label
 #label = <b>miscellaneous</b> / label
 van3prod = 0.002 / double
 van3autokat = 0.1 / double
 van3sat = 10 / double
 k2van3 = 0.3 / double
 #glvprod = 0.0 / double
 #glvbreakdown = 0. / double
 label = / label
 label = <b>Integration parameters</b> / label
 dt = 0.1 / double
 rd_dt = 1.0 / double
 datadir = . / directory
 movie = false / bool
 nit = 100000 / int
 maxt = 1000. / double
 storage_stride = 10 / int
 xml_storage_stride = 500 / int
 rseed = -1 / int
 #label = / label
 #label = <b>Parameters for new chemical</b> / label
 #glvproduction = 0. / double
 #glvdecay = 0. / double
 #glvdiffthreshold = 0. / double
 label = / label
 label = <b>Meinhardt leaf venation model</b> / label
 constituous_expansion_limit = 16 / int
 vessel_inh_level = 1 / double
 vessel_expansion_rate = 0.25 / double
 d = 0. / double
 e = 0. / double
 f = 0. / double
 c = 0. / double
 mu = 0. / double
 nu = 0. / double
 rho0 = 0. / double
 rho1 = 0. / double
 c0 = 0. / double
 gamma = 0. / double
 eps = 0. / double
 label = / label
 label = <b>User-defined parameters</b> / label
 k = 0., 0.0, 0.0, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0. / doublelist
 i1 = 0 / int
 i2 = 0 / int
 i3 = 0 / int
 i4 = 0 / int
 i5 = 0 / int
 s1 =  / string
 s2 =  / string
 s3 =  / string
 b1 = false / bool
 b2 = false / bool
 b3 = false / bool
 b4 = false / bool
 dir1 = . / directory
 dir2 = . / directory

src/build_models/Makefile

➞

Show inline comments

 # $Id$
 QMAKE = qmake
 all: plugin_auxingrowth plugin_leaf plugin_meinhardt plugin_test
 plugin_auxingrowth: Makefile.plugin_auxingrowth
 	make -f Makefile.plugin_auxingrowth
 Makefile.plugin_auxingrowth: plugin_auxingrowth.pro
-	qmake -makefile -o $@ $<
+	$(QMAKE) -makefile -o $@ $<
 plugin_leaf: Makefile.plugin_leaf
 	make -f Makefile.plugin_leaf
 Makefile.plugin_leaf: plugin_leaf.pro
-	qmake -makefile -o $@ $<
+	$(QMAKE) -makefile -o $@ $<
 plugin_meinhardt: Makefile.plugin_meinhardt
 	make -f Makefile.plugin_meinhardt
 Makefile.plugin_meinhardt: plugin_meinhardt.pro
-	qmake -makefile -o $@ $<
+	$(QMAKE) -makefile -o $@ $<
 plugin_test: Makefile.plugin_test
 	make -f Makefile.plugin_test
 Makefile.plugin_test: plugin_test.pro
-	qmake -makefile -o $@ $<
+	$(QMAKE) -makefile -o $@ $<
 clean:
 	make -f Makefile.plugin_auxingrowth clean
 	make -f Makefile.plugin_leaf clean
 	make -f Makefile.plugin_meinhardt clean
 	make -f Makefile.plugin_test clean
 #finis

src/build_models/auxingrowthplugin.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
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "../simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "auxingrowthplugin.h"
 #include "far_mem_5.h"
 static const std::string _module_id("$Id$");
 bool batch = false;
 // To be executed after cell division
-void AuxinGrowthPlugin::OnDivide(ParentInfo &parent_info, CellBase &daughter1, CellBase &daughter2) {
+void AuxinGrowthPlugin::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
 	// Auxin distributes between parent and daughter according to area
-	double area1 = daughter1.Area(), area2 = daughter2.Area();
+	double area1 = daughter1->Area(), area2 = daughter2->Area();
 	double tot_area = area1 + area2;
 	daughter1.SetChemical(0,daughter1.Chemical(0)*(area1/tot_area));
 	daughter2.SetChemical(0,daughter2.Chemical(0)*(area2/tot_area));
 	daughter1->SetChemical(0,daughter1->Chemical(0)*(area1/tot_area));
 	daughter2->SetChemical(0,daughter2->Chemical(0)*(area2/tot_area));
 	// After divisions, parent and daughter cells get a standard stock of PINs.
 	daughter1.SetChemical(1, par->initval[1]);
 	daughter2.SetChemical(1, par->initval[1]);
 	daughter1->SetChemical(1, par->initval[1]);
 	daughter2->SetChemical(1, par->initval[1]);
 	// Reset transporter values of parent and daughter
 	QList<WallBase *> walls;
 	foreach(WallBase *w, walls) {
-		w->setTransporter(&daughter1, 1, 0.);
 		w->setTransporter(daughter1, 1, 0.);
+	}
 	//daughter1.LoopWalls(Wall::setTransporter(&daughter1, 1, 0.));
 	/* for (list<Wall *>::const_iterator w=daughter2.walls.begin();
 		 w!=daughter2.walls.end();
 		 w++) {
 		// reset transporter value
 		(*w)->setTransporter(&daughter2, 1, 0.);
+	}
 	*/
+}
-void AuxinGrowthPlugin::SetCellColor(CellBase &c, QColor &color) {
+void AuxinGrowthPlugin::SetCellColor(CellBase *c, QColor *color) {
 	// Red: PIN1
 	// Green: Auxin
 	if (c.CellType()==1) color = QColor("Blue");
 	else color.setRgb(c.Chemical(1)/(1+c.Chemical(1)) * 255.,(c.Chemical(0)/(1+c.Chemical(0)) * 255.),/* (chem[2]/(1+chem[2]) *255.) */ 0);
 	if (c->CellType()==1) color->setNamedColor("Blue");
 	else color->setRgb(c->Chemical(1)/(1+c->Chemical(1)) * 255.,(c->Chemical(0)/(1+c->Chemical(0)) * 255.),/* (chem[2]/(1+chem[2]) *255.) */ 0);
+}
-void AuxinGrowthPlugin::CellHouseKeeping(CellBase &c) {
+void AuxinGrowthPlugin::CellHouseKeeping(CellBase *c) {
 	if (c.Boundary()==CellBase::None) {
 		if (c.Area() > par->rel_cell_div_threshold * c.BaseArea() ) {
 			c.SetChemical(0,0);
 			c.Divide();
 	if (c->Boundary()==CellBase::None) {
 		if (c->Area() > par->rel_cell_div_threshold * c->BaseArea() ) {
 			c->SetChemical(0,0);
 			c->Divide();
+        }
 		if (c.Chemical(0)>0.6) {
 			c.SetCellType(1);
 		if (c->Chemical(0)>0.6) {
 			c->SetCellType(1);
+		}
 		// expand according to auxin concentration
-   		c.EnlargeTargetArea(par->auxin_dependent_growth?(c.Chemical(0)/(1.+c.Chemical(0)))*par->cell_expansion_rate:par->cell_expansion_rate);
+   		c->EnlargeTargetArea(par->auxin_dependent_growth?(c->Chemical(0)/(1.+c->Chemical(0)))*par->cell_expansion_rate:par->cell_expansion_rate);
+	}
+}
 void AuxinGrowthPlugin::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
 	// leaf edge is const source of auxin
     // (Neumann boundary condition: we specify the influx)
     if (w->C2()->BoundaryPolP()) {
 		if (w->AuxinSource()) {
 			double aux_flux = par->leaf_tip_source * w->Length();
 			dchem_c1[0]+= aux_flux;
 			// dchem_c2 is undefined..!
 			return;
 		} else {
 			return;
+		}
+	}
 	if (w->C1()->BoundaryPolP()) {
 		if (w->AuxinSource()) {
 			double aux_flux = par->leaf_tip_source * w->Length();
 			dchem_c2[0] += aux_flux;
 			// dchem_c1 is undefined...!
 			return;
 		} else {
 			if (w->AuxinSink()) {
 				// efflux into Shoot Apical meristem
 				// we assume all PINs are directed towards shoot apical meristem
 				dchem_c2[0] -= par->sam_efflux * w->C2()->Chemical(0) / (par->ka + w->C2()->Chemical(0));
 				return;
 			} else
 				return;
+		}
+    }
 	// Passive fluxes (Fick's law)
     // only auxin flux now
     // flux depends on edge length and concentration difference
     int c=0;
     double phi = w->Length() * ( par->D[c] ) * ( w->C2()->Chemical(c) - w->C1()->Chemical(c) );
     dchem_c1[c] += phi;
     dchem_c2[c] -= phi;
     // Active fluxes (PIN1 mediated transport)
     // (Transporters measured in moles, here)
     // efflux from cell 1 to cell 2
     double trans12 = ( par->transport * w->Transporters1(1) * w->C1()->Chemical(0) / (par->ka + w->C1()->Chemical(0)) );
     // efflux from cell 2 to cell 1
     double trans21 = ( par->transport * w->Transporters2(1) * w->C2()->Chemical(0) / (par->ka + w->C2()->Chemical(0)) );
     dchem_c1[0] += trans21 - trans12;
     dchem_c2[0] += trans12 - trans21;
+}
 void AuxinGrowthPlugin::WallDynamics(Wall *w, double *dw1, double *dw2) {
     // Cells polarize available PIN1 to Shoot Apical Meristem
     if (w->C2()->BoundaryPolP()) {
 		if (w->AuxinSink()) {
 			dw1[0] = 0.; dw2[0] = 0.;
 			//dw1[2] = 0.; dw2[2] = 0.;
 			// assume high auxin concentration in SAM, to convince PIN1 to polarize to it
 			// exocytosis regulated0
 			double nb_auxin = par->sam_auxin;
 			double receptor_level = nb_auxin * par->r / (par->kr + nb_auxin);
 			dw1[1] = par->k1 * w->C1()->Chemical(1) * receptor_level /( par->km + w->C1()->Chemical(1) ) - par->k2 * w->Transporters1(1);
 			dw2[1] = 0.;
 			return;
 		} else {
 			dw1[0]=dw2[0]=dw1[1]=dw2[1];//=dw1[2]=dw2[2];
 			return;
+		}
+    }
     if (w->C1()->BoundaryPolP()) {
 		if (w->AuxinSink())  {
 			dw1[0] = 0.; dw2[0] = 0.;
 			//dw1[2] = 0.; dw2[2] = 0.;
 			// assume high auxin concentration in SAM, to convince PIN1 to polarize to it
 			// exocytosis regulated
 			double nb_auxin = par->sam_auxin;
 			double receptor_level = nb_auxin * par->r / (par->kr + nb_auxin);
 			dw2[1] = par->k1 * w->C2()->Chemical(1) * receptor_level /( par->km + w->C2()->Chemical(1) ) - par->k2 * w->Transporters2(1);
 			dw1[1] = 0.;
 			return;
 		}  else {
 			dw1[0]=dw2[0]=dw1[1]=dw2[1];//=dw1[2]=dw2[2];
 			return;
+		}
+    }
     // PIN1 localization at wall 1
     // Note: chemical 0 is Auxin (intracellular storage only)
     // Chemical 1 is PIN1 (walls and intracellular storage)
     //! \f$ \frac{d Pij/dt}{dt} = k_1 A_j \frac{P_i}{L_ij} - k_2 P_{ij} \f$
     // Note that Pij is measured in term of concentration (mol/L)
     // Pi in terms of quantity (mol)
     double dPijdt1=0., dPijdt2=0.;
     // normal cell
     double  auxin2 = w->C2()->Chemical(0);
     double receptor_level1 = auxin2 * par->r / (par->kr + auxin2);
     dPijdt1 =
 	// exocytosis regulated
     par->k1 * w->C1()->Chemical(1) * receptor_level1 / ( par->km + w->C1()->Chemical(1) ) - par->k2 * w->Transporters1(1);
     double  auxin1 = w->C1()->Chemical(0);
     double receptor_level2 = auxin1 * par->r / (par->kr + auxin1);
     // normal cell
     dPijdt2 =
 	// exocytosis regulated
 	par->k1 * w->C2()->Chemical(1) * receptor_level2 / ( par->km + w->C2()->Chemical(1) ) - par->k2 * w->Transporters2(1);
     /* PIN1 of neighboring vascular cell inhibits PIN1 endocytosis */
     dw1[0] = 0.; dw2[0] = 0.;
     //dw1[2] = 0.; dw2[2] = 0.;
     dw1[1] = dPijdt1;
     dw2[1] = dPijdt2;
+}
-double AuxinGrowthPlugin::complex_PijAj(CellBase &here, CellBase &nb, Wall &w) {
+double AuxinGrowthPlugin::complex_PijAj(CellBase *here, CellBase *nb, Wall *w) {
 	// gives the amount of complex "auxinreceptor-Pin1"  at the wall (at QSS)
 	//return here.Chemical(1) * nb.Chemical(0) / ( par->km + here.Chemical(1));
-	double nb_aux = (nb.BoundaryPolP() && w.AuxinSink()) ? par->sam_auxin : nb.Chemical(0);
+	double nb_aux = (nb->BoundaryPolP() && w->AuxinSink()) ? par->sam_auxin : nb->Chemical(0);
 	double receptor_level = nb_aux * par->r / (par->kr + nb_aux);
-	return here.Chemical(1) * receptor_level / ( par->km + here.Chemical(1));
+	return here->Chemical(1) * receptor_level / ( par->km + here->Chemical(1));
+}
 void AuxinGrowthPlugin::CellDynamics(CellBase *c, double *dchem) {
 	// Note: Pi and Pij measured in numbers of molecules, not concentrations
 		double dPidt = 0.;
 		double sum_Pij = c->SumTransporters( 1 );
 		// exocytosis regulated:
 	dPidt = -par->k1 * c->ReduceCellAndWalls<double>( far_3_arg_mem_fun( *this, &AuxinGrowthPlugin::complex_PijAj ) ) + par->k2 * sum_Pij;
 	/*for ( list<Wall *>::const_iterator w = c->walls.begin();
 		 w!=walls.end();
 		 w++) {
 		if ((*w)->C1() == c)
 			dPidt +=  complex_PijAj( (*w)->C1(), (*w)->C2(), *w );
 		else
 			dPidt +=  complex_PijAj( (*w)->C2(), (*w)->C1(), *w );
 	}*/
 	// production of PIN depends on auxin concentration
 	dPidt +=  (c->AtBoundaryP()?par->pin_prod_in_epidermis:par->pin_prod) * c->Chemical(0) - c->Chemical(1) * par->pin_breakdown;
 	// no PIN production in SAM
 	if (c->Boundary() == CellBase::SAM) {
 			dchem[1]=0.;
 		dchem[0]= - par->sam_auxin_breakdown * c->Chemical(0);
 	} else {
 		dchem[1] = dPidt;
 		// source of auxin
 		dchem[0] = par->aux_cons - par->aux_breakdown * c->Chemical(0);
+	}
+}
 Q_EXPORT_PLUGIN2(auxingrowthplugin, AuxinGrowthPlugin)

src/build_models/auxingrowthplugin.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
  *  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.
+ *
  */
 #ifndef _AUXINGROWTHPLUGIN_H_
 #define _AUXINGROWTHPLUGIN_H_
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "../simplugin.h"
 class AuxinGrowthPlugin : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void) { return QString( "Auxin accumulation and growth" ); }
 	// Executed after the cellular mechanics steps have equillibrized
-	virtual void CellHouseKeeping (CellBase &c);
+	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
-	virtual void OnDivide(ParentInfo &parent_info, CellBase &daughter1, CellBase &daughter2);
+	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
-	virtual void SetCellColor(CellBase &c, QColor &color);
+	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void) { return 2; }
 private:
-	double complex_PijAj(CellBase &here, CellBase &nb, Wall &w);
+	double complex_PijAj(CellBase *here, CellBase *nb, Wall *w);
 };
 #endif

src/build_models/leafplugin.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
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "leafplugin.h"
 #include "far_mem_5.h"
 static const std::string _module_id("$Id$");
 bool batch = false;
 // To be executed after cell division
-void LeafPlugin::OnDivide(ParentInfo &parent_info, CellBase &daughter1, CellBase &daughter2) {
+void LeafPlugin::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
 		// PIN1 distributes between parent and daughter according to area
-  double area = daughter1.Area(), daughter_area = daughter2.Area();
+  double area = daughter1->Area(), daughter_area = daughter2->Area();
   double tot_area = area + daughter_area;
   //chem[1]*=(area/tot_area);
   //daughter.chem[1]*=(daughter_area/tot_area);
   // For lack of detailed data, or a better rule, we assume that cells remain polarized
   // after division
   // So the PIN1 is redistributed according to the original polarization over the walls
   // parent_info contains info about the parent
   // redistribute the PIN in the endosome according to area
 	// "Fudge" rule: if one of the cells is at the boundary, remove all AUX1 in the other cell
   if (daughter1.AtBoundaryP() && !daughter2.AtBoundaryP()) {
     //daughter2.new_chem[2]=daughter2.chem[2]=0.;
 		daughter2.SetNewChem(2,0);
 		daughter2.SetChemical(2,0);
   if (daughter1->AtBoundaryP() && !daughter2->AtBoundaryP()) {
     //daughter2->new_chem[2]=daughter2->chem[2]=0.;
 		daughter2->SetNewChem(2,0);
 		daughter2->SetChemical(2,0);
 		//daughter.new_chem[0]=daughter.chem[0]=0.;
 		//cerr << "Clearing daughter\n";
 		//for (list<Wall *>::const_iterator w=daughter.walls.begin();
 		//	 w!=daughter.walls.end();
 		//	 w++) {
 		//	(*w)->setTransporter(&daughter, 1, 0.);
 		//}
 		//new_chem[2]=chem[2]=parent_info.PINendosome;
 		daughter1.SetNewChem(2,parent_info.PINendosome);
 		daughter1.SetChemical(2,parent_info.PINendosome);
 		//new_chem[2]=chem[2]=parent_info->PINendosome;
 		daughter1->SetNewChem(2,parent_info->PINendosome);
 		daughter1->SetChemical(2,parent_info->PINendosome);
 	} else {
-		if (daughter2.AtBoundaryP() && !daughter1.AtBoundaryP()) {
+		if (daughter2->AtBoundaryP() && !daughter1->AtBoundaryP()) {
 		  //new_chem[2]=chem[2]=0.;
 		  daughter1.SetNewChem(2,0);
 		  daughter1.SetChemical(2,0);
 		  daughter1->SetNewChem(2,0);
 		  daughter1->SetChemical(2,0);
 			/*new_chem[0]=chem[0]=0.;
 			for (list<Wall *>::const_iterator w=walls.begin();
 				 w!=walls.end();
 				 w++) {
 				(*w)->setTransporter(this, 1, 0.);
 			}*/
 		  //daughter2.chem[2]=parent_info.PINendosome;
 		  daughter2.SetChemical(2,parent_info.PINendosome);
 		  //daughter2->chem[2]=parent_info->PINendosome;
 		  daughter2->SetChemical(2,parent_info->PINendosome);
 		  //cerr << "Clearing parent\n";
 		} else {
 		  //daughter1.new_chem[2]=daughter1.chem[2] = parent_info.PINendosome*(area/tot_area);
 		  daughter1.SetNewChem(2,parent_info.PINendosome*(area/tot_area));
 		  daughter1.SetChemical(2, parent_info.PINendosome*(area/tot_area));
 		  //daughter2.new_chem[2]=daughter2.chem[2] = parent_info.PINendosome*(daughter_area/tot_area);
 		  daughter2.SetNewChem(2,parent_info.PINendosome*(daughter_area/tot_area));
 		  daughter2.SetChemical(2,parent_info.PINendosome*(daughter_area/tot_area));
 		  //daughter1->new_chem[2]=daughter1->chem[2] = parent_info->PINendosome*(area/tot_area);
 		  daughter1->SetNewChem(2,parent_info->PINendosome*(area/tot_area));
 		  daughter1->SetChemical(2, parent_info->PINendosome*(area/tot_area));
 		  //daughter2->new_chem[2]=daughter2->chem[2] = parent_info->PINendosome*(daughter_area/tot_area);
 		  daughter2->SetNewChem(2,parent_info->PINendosome*(daughter_area/tot_area));
 		  daughter2->SetChemical(2,parent_info->PINendosome*(daughter_area/tot_area));
+		}
+	}
 	/*
 	  // NB: Code commented out; not yet adapted to plugin format... RM 18/12/2009
 	// Now redistribute the membrane PINs according to the original polarization in the parent
 	// mmm... I'd like to have a better, biologically motivated rule for this,
 	// but for lack of something better... I hope I'm excused :-). Let's say the overall
 	// organization of the actin fibres is not completely destroyed after division...
 	// distribute wallPINs according to the circumference of the parent and daughter
 	double circ = Circumference( );
 	double daughter_circ = daughter.Circumference();
 	double tot_circ = circ + daughter_circ;
 	double wallPINs = (circ / tot_circ) * parent_info.PINmembrane;
 	double daughter_wallPINs = (daughter_circ / tot_circ) * parent_info.PINmembrane;
 	double wallPINs = (circ / tot_circ) * parent_info->PINmembrane;
 	double daughter_wallPINs = (daughter_circ / tot_circ) * parent_info->PINmembrane;
-     	//cerr << "wallPINs = " << wallPINs <<  ", daughter_wallPINs =  " << daughter_wallPINs << "sum = " << wallPINs + daughter_wallPINs << ", PINmembrane = " << parent_info.PINmembrane << endl;
+     	//cerr << "wallPINs = " << wallPINs <<  ", daughter_wallPINs =  " << daughter_wallPINs << "sum = " << wallPINs + daughter_wallPINs << ", PINmembrane = " << parent_info->PINmembrane << endl;
 	// distrubute it according to the overall polarity
-	Vector polarization = parent_info.polarization.Normalised().Perp2D();
+	Vector polarization = parent_info->polarization.Normalised().Perp2D();
 	double sum=0.;
 	for (list<Wall *>::const_iterator w=walls.begin();
 		 w!=walls.end();
 		 w++) {
 		// distribute according to angle (0 degrees: maximum, 180 degrees minimum)
 		double tmp=InnerProduct((*w)->getWallVector(this),polarization); // move domain from [-1,1] to [0,1]
 		cerr << "[" << tmp << "]";
 		sum+=tmp;
 		//(*w)->setTransporter(this, 1,
+	}
 	//cerr << "Sum is " << sum << endl;
 	//double sum_wall_Pi = SumTransporters(1);
 	// After division, cells produce PIN1 (in intracellular storage) until total amount becomes Pi_tot
 	//SetChemical(1, par.Pi_tot - sum_wall_Pi  );
 	//SetNewChem(1, Chemical(1));
 	//cerr << "[ "  << sum_wall_Pi + Chemical(1) << "]";
 	*/
+}
-void LeafPlugin::SetCellColor(CellBase &c, QColor &color) {
+void LeafPlugin::SetCellColor(CellBase *c, QColor *color) {
 	// Red: AUX1
 	// Green: Auxin
 	// Blue: van-3
   //  color.setRgb(chem[2]/(1+chem[2]) * 255.,(chem[0]/(1+chem[0]) * 255.),(chem[3]/(1+chem[3]) *255.) );
   color.setRgb(c.Chemical(2)/(1+c.Chemical(2)) * 255.,(c.Chemical(0)/(1+c.Chemical(0)) * 255.),(c.Chemical(3)/(1+c.Chemical(3)) *255.) );
   //  color->setRgb(chem[2]/(1+chem[2]) * 255.,(chem[0]/(1+chem[0]) * 255.),(chem[3]/(1+chem[3]) *255.) );
   color->setRgb(c->Chemical(2)/(1+c->Chemical(2)) * 255.,(c->Chemical(0)/(1+c->Chemical(0)) * 255.),(c->Chemical(3)/(1+c->Chemical(3)) *255.) );
+}
-void LeafPlugin::CellHouseKeeping(CellBase &c) {
+void LeafPlugin::CellHouseKeeping(CellBase *c) {
   if (c.Boundary()==CellBase::None) {
     if (c.Area() > par->rel_cell_div_threshold * c.BaseArea() ) {
       //c.SetChemical(0,0);
       c.Divide();
   if (c->Boundary()==CellBase::None) {
     if (c->Area() > par->rel_cell_div_threshold * c->BaseArea() ) {
       //c->SetChemical(0,0);
       c->Divide();
+    }
     // expand if this is not a provascular cell
     if (c.Chemical(3) < 0.7 ) {
       c.EnlargeTargetArea(par->cell_expansion_rate);
     if (c->Chemical(3) < 0.7 ) {
       c->EnlargeTargetArea(par->cell_expansion_rate);
+    }
+  }
+}
 void LeafPlugin::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
   // leaf edge is const source of auxin
   // (Neumann boundary condition: we specify the influx)
   if (w->C2()->BoundaryPolP()) {
     if (w->AuxinSource()) {
       double aux_flux = par->leaf_tip_source * w->Length();
       dchem_c1[0]+= aux_flux;
       // dchem_c2 is undefined..!
       return;
     } else {
       if (w->AuxinSink()) {
 	// efflux into Shoot Apical meristem
 	// we assume all PINs are directed towards shoot apical meristem
 	dchem_c1[0] -= par->sam_efflux * w->C1()->Chemical(0) / (par->ka + w->C1()->Chemical(0));
 	return;
       } else {
 	// Active fluxes (PIN1 and AUX1 mediated transport)
 	// (Transporters measured in moles, here)
 	// efflux from cell 1 to cell 2
 	double trans12 = ( par->transport * w->Transporters1(1) * w->C1()->Chemical(0) / (par->ka + w->C1()->Chemical(0))
 			   + par->aux1transport * w->C2()->Chemical(2) * w->C1()->Chemical(0) / (par->kaux1 + w->C1()->Chemical(0)) );
 	// efflux from cell 2 to cell 1
 	double trans21 = ( par->transport * w->Transporters2(1) * w->C2()->Chemical(0) / (par->ka + w->C2()->Chemical(0))
 			   + par->aux1transport * w->C1()->Chemical(2) * w->C2()->Chemical(0) / (par->kaux1 + w->C2()->Chemical(0)) );
 	dchem_c1[0] += trans21 - trans12;
 	dchem_c2[0] += trans12 - trans21;
 	return;
+      }
+    }
+  }
   if (w->C1()->BoundaryPolP()) {
     if (w->AuxinSource()) {
       double aux_flux = par->leaf_tip_source * w->Length();
       dchem_c2[0] += aux_flux;
       // dchem_c1 is undefined...!
       return;
     } else {
       if (w->AuxinSink()) {
 	// efflux into Shoot Apical meristem
 	// we assume all PINs are directed towards shoot apical meristem
 	// no passive fluxes: outside is impermeable
 	// Active fluxes (PIN1 and AUX1 mediated transport)
 	// (Transporters measured in moles, here)
 	// efflux from cell 1 to cell 2
 	// assumption: no AUX1 in shoot apical meristem
 	double trans12 = ( par->transport * w->Transporters1(1) * w->C1()->Chemical(0) / (par->ka + w->C1()->Chemical(0)));
 	dchem_c1[0] +=  - trans12;
 	return;
 	//dchem_c2[0] -= par->sam_efflux * w->C2()->Chemical(0) / (par->ka + w->C2()->Chemical(0));
 	// return;
       }  else {
+      }
+    }
+  }
   // Passive fluxes (Fick's law)
   // only auxin flux now
   // flux depends on edge length and concentration difference
   for (int c=0;c<NChem();c++) {
     double phi = w->Length() * ( par->D[c] ) * ( w->C2()->Chemical(c) - w->C1()->Chemical(c) );
     dchem_c1[c] += phi;
     dchem_c2[c] -= phi;
+  }
   // Active fluxes (PIN1 and AUX1 mediated transport)
   // (Transporters measured in moles, here)
   // efflux from cell 1 to cell 2
   double trans12 = ( par->transport * w->Transporters1(1) * w->C1()->Chemical(0) / (par->ka + w->C1()->Chemical(0))
 		     + par->aux1transport * w->C2()->Chemical(2) * w->C1()->Chemical(0) / (par->kaux1 + w->C1()->Chemical(0)) );
   // efflux from cell 2 to cell 1
   double trans21 = ( par->transport * w->Transporters2(1) * w->C2()->Chemical(0) / (par->ka + w->C2()->Chemical(0))
 		     + par->aux1transport * w->C1()->Chemical(2) * w->C2()->Chemical(0) / (par->kaux1 + w->C2()->Chemical(0)) );
   dchem_c1[0] += trans21 - trans12;
   dchem_c2[0] += trans12 - trans21;
+}
 void LeafPlugin::WallDynamics(Wall *w, double *dw1, double *dw2) {
   // Cells polarize available PIN1 to Shoot Apical Meristem
   if (w->C2()->BoundaryPolP()) {
     if (w->AuxinSink()) {
       dw1[0] = 0.; dw2[0] = 0.;
       dw1[2] = 0.; dw2[2] = 0.;
       // assume high auxin concentration in SAM, to convince PIN1 to polarize to it
       // exocytosis regulated0
       double nb_auxin = par->sam_auxin;
       double receptor_level = nb_auxin * par->r / (par->kr + nb_auxin);
       dw1[1] = par->k1 * w->C1()->Chemical(1) * receptor_level /( par->km + w->C1()->Chemical(1) ) - par->k2 * w->Transporters1(1);
       dw2[1] = 0.;
       return;
     } else {
       dw1[0]=dw2[0]=dw1[1]=dw2[1]=dw1[2]=dw2[2];
       return;
+    }
+  }
   if (w->C1()->BoundaryPolP()) {
     if (w->AuxinSink())  {
       dw1[0] = 0.; dw2[0] = 0.;
       dw1[2] = 0.; dw2[2] = 0.;
       // assume high auxin concentration in SAM, to convince PIN1 to polarize to it
       // exocytosis regulated
       double nb_auxin = par->sam_auxin;
       double receptor_level = nb_auxin * par->r / (par->kr + nb_auxin);
       dw2[1] = par->k1 * w->C2()->Chemical(1) * receptor_level /( par->km + w->C2()->Chemical(1) ) - par->k2 * w->Transporters2(1);
       dw1[1] = 0.;
       return;
     }  else {
       dw1[0]=dw2[0]=dw1[1]=dw2[1]=dw1[2]=dw2[2];
       return;
+    }
+  }
   // PIN1 localization at wall 1
   // Note: chemical 0 is Auxin (intracellular storage only)
   // Chemical 1 is PIN1 (walls and intracellular storage)
   //! \f$ \frac{d Pij/dt}{dt} = k_1 A_j \frac{P_i}{L_ij} - k_2 P_{ij} \f$
   // Note that Pij is measured in term of concentration (mol/L)
   // Pi in terms of quantity (mol)
   double dPijdt1=0., dPijdt2=0.;
   // normal cell
   double  auxin2 = w->C2()->Chemical(0);
   double receptor_level1 = auxin2 * par->r / (par->kr + auxin2);
   dPijdt1 =
     // exocytosis regulated
     par->k1 * w->C1()->Chemical(1) * receptor_level1 / ( par->km + w->C1()->Chemical(1) ) - par->k2 * w->Transporters1(1);
   double  auxin1 = w->C1()->Chemical(0);
   double receptor_level2 = auxin1 * par->r / (par->kr + auxin1);
   // normal cell
   dPijdt2 =
     // exocytosis regulated
     par->k1 * w->C2()->Chemical(1) * receptor_level2 / ( par->km + w->C2()->Chemical(1) ) - par->k2 * w->Transporters2(1);
   /* PIN1 of neighboring vascular cell inhibits PIN1 endocytosis */
   dw1[0] = 0.; dw2[0] = 0.;
   dw1[2] = 0.; dw2[2] = 0.;
   dw1[1] = dPijdt1;
   dw2[1] = dPijdt2;
+}
-double LeafPlugin::complex_PijAj(CellBase &here, CellBase &nb, Wall &w) {
+double LeafPlugin::complex_PijAj(CellBase *here, CellBase *nb, Wall *w) {
   // gives the amount of complex "auxinreceptor-Pin1"  at the wall (at QSS)
   //return here.Chemical(1) * nb.Chemical(0) / ( par->km + here.Chemical(1));
-  double nb_aux = (nb.BoundaryPolP() && w.AuxinSink()) ? par->sam_auxin : nb.Chemical(0);
+  double nb_aux = (nb->BoundaryPolP() && w->AuxinSink()) ? par->sam_auxin : nb->Chemical(0);
   double receptor_level = nb_aux * par->r / (par->kr + nb_aux);
-  return here.Chemical(1) * receptor_level / ( par->km + here.Chemical(1));
+  return here->Chemical(1) * receptor_level / ( par->km + here->Chemical(1));
+}
 void LeafPlugin::CellDynamics(CellBase *c, double *dchem) {
   double dPidt = 0.;
   double sum_Pij = c->SumTransporters( 1 );
   // exocytosis regulated:
   // van3 expression reduces rate of PIN1 endocytosis
   dPidt = -par->k1 * c->ReduceCellAndWalls<double>( far_3_arg_mem_fun( *this, &LeafPlugin::complex_PijAj ) ) +
     (c->Chemical(3) < 0.5 ? par->k2 : par->k2van3) * sum_Pij;
   // production of PIN depends on auxin concentration
   dPidt +=  (c->AtBoundaryP()?par->pin_prod_in_epidermis:par->pin_prod) * c->Chemical(0) - c->Chemical(1) * par->pin_breakdown;
   /*if (c->AtBoundaryP()) {
     dchem[2] = 0.01;
     //cerr << "Making cell blue.\n";
     } else {
     dchem[2] = -0.1 * c->Chemical(2);
     }*/
   // no PIN production in SAM
   if (c->Boundary() == CellBase::SAM) {
     dchem[1]=0.;
     dchem[0]= - par->sam_auxin_breakdown * c->Chemical(0);
     dchem[2]=0.;
   } else {
     dchem[1] = dPidt;
     // source of auxin
     dchem[0] = par->aux_cons;
     // auxin-induced AUX1 production, in the epidermis
     dchem[2] = ( c->AtBoundaryP() ? par->aux1prod : par->aux1prodmeso ) * ( c->Chemical(0)  / ( 1. + par->kap * c->Chemical(0) ) ) - ( par->aux1decay ) * c->Chemical(2) ;//: 0.;
     // auxin-induced production of VAN-3? Autokatalysis?
     //dchem[3] = par->van3prod * (c->Chemical(0) / (1. + par->kvp * c-> Chemical(0) ) )
     double A = c->Chemical(0);
     double van3 = c->Chemical(3);
     dchem[3] = par->van3prod * A - par->van3autokat * van3 + van3*van3/(1 + par->van3sat * van3*van3 );
+  }
+}
 Q_EXPORT_PLUGIN2(leafplugin, LeafPlugin)

src/build_models/leafplugin.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
  *  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.
+ *
  */
 #ifndef _LEAFPLUGIN_H_
 #define _LEAFPLUGIN_H_
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "../simplugin.h"
 class LeafPlugin : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void) { return QString( "Traveling wave model with influx carriers - Merks and Beemster, 2006-2008" ); }
 	// Executed after the cellular mechanics steps have equillibrized
-	virtual void CellHouseKeeping (CellBase &c);
+	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
-	virtual void OnDivide(ParentInfo &parent_info, CellBase &daughter1, CellBase &daughter2);
+	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
-	virtual void SetCellColor(CellBase &c, QColor &color);
+	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void) { return 4; }
  private:
-	double complex_PijAj(CellBase &here, CellBase &nb, Wall &w);
+	double complex_PijAj(CellBase *here, CellBase *nb, Wall *w);
 };
 #endif

src/build_models/meinhardtplugin.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
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
+#include "../simplugin.h"
 #include "parameter.h"
 #include "warning.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "meinhardtplugin.h"
 static const std::string _module_id("$Id$");
 bool batch = false;
 // To be executed after cell division
-void MeinhardtPlugin::OnDivide(ParentInfo &parent_info, CellBase &daughter1, CellBase &daughter2) {
+void MeinhardtPlugin::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
+}
-void MeinhardtPlugin::SetCellColor(CellBase &c, QColor &color) {
+void MeinhardtPlugin::SetCellColor(CellBase *c, QColor *color) {
-	if (fpclassify(c.Chemical(0))==FP_NAN) {
+	if (fpclassify(c->Chemical(0))==FP_NAN) {
 		// somehow the function isnan doesn't work properly on my system... SuSE Linux
 		// 10.0 64-bits (isnan seems not be implemented using fpclassify).
 		MyWarning::warning("Whoops! Numerical instability!!");
-		color.setNamedColor("red");
+		color->setNamedColor("red");
 	} else {
 		double range_min = 0.;//, range_max = 1.;
-		if (c.Chemical(0)<range_min) {
+		if (c->Chemical(0)<range_min) {
 			MyWarning::warning("Whoops! Numerical instability!!");
-			color.setNamedColor("blue");
+			color->setNamedColor("blue");
 		} else {
-			color.setRgb(c.Chemical(1)/(1+c.Chemical(1)) * 255.,(c.Chemical(0)/(1+c.Chemical(0)) * 255.),(c.Chemical(3)/(1+c.Chemical(3)) *255.) );
+			color->setRgb(c->Chemical(1)/(1+c->Chemical(1)) * 255.,(c->Chemical(0)/(1+c->Chemical(0)) * 255.),(c->Chemical(3)/(1+c->Chemical(3)) *255.) );
+		}
+	}
+}
-void MeinhardtPlugin::CellHouseKeeping(CellBase &c) {
+void MeinhardtPlugin::CellHouseKeeping(CellBase *c) {
 	if (c.Area() > par->rel_cell_div_threshold * c.BaseArea() ) {
 		c.Divide();
 	if (c->Area() > par->rel_cell_div_threshold * c->BaseArea() ) {
 		c->Divide();
+	}
     // cell expansion is inhibited by substrate (chem 3)
 	if (!par->constituous_expansion_limit || c.NCells()<par->constituous_expansion_limit) {
 		c.EnlargeTargetArea(par->cell_expansion_rate );
 	if (!par->constituous_expansion_limit || c->NCells()<par->constituous_expansion_limit) {
 		c->EnlargeTargetArea(par->cell_expansion_rate );
 	} else {
-		if (c.Chemical(0)<0.5) {
+		if (c->Chemical(0)<0.5) {
 			double tmp;
-			c.EnlargeTargetArea((tmp=(1.-par->vessel_inh_level*c.Chemical(3))*par->cell_expansion_rate /* + c.Chemical(4)*/)<0?0:tmp);
+			c->EnlargeTargetArea((tmp=(1.-par->vessel_inh_level*c->Chemical(3))*par->cell_expansion_rate /* + c->Chemical(4)*/)<0?0:tmp);
 		} else {
-			c.EnlargeTargetArea(par->vessel_expansion_rate);
+			c->EnlargeTargetArea(par->vessel_expansion_rate);
+		}
+	}
+}
 void MeinhardtPlugin::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
 	// No flux boundaries for all chemicals, except activator: boundary is sink
   if (w->C1()->BoundaryPolP() || w->C2()->BoundaryPolP()) {
 		if (w->C1()->BoundaryPolP()) {
 			dchem_c2[1] -=  w->Length() * ( par->D[1] ) * ( w->C2()->Chemical(1) );
 			} else {
 			dchem_c1[1] -=  w->Length() * ( par->D[1] ) * ( w->C1()->Chemical(1) );
+			}
 		return;
+		}
     // Passive fluxes (Fick's law)
     for (int c=0;c<NChem();c++) {
 		double phi = w->Length() * ( par->D[c] ) * ( w->C2()->Chemical(c) - w->C1()->Chemical(c) );
 		dchem_c1[c] += phi;
 		dchem_c2[c] -= phi;
+	}
+}
 void MeinhardtPlugin::WallDynamics(Wall *w, double *dw1, double *dw2) {
 	for (int c = 0;c<NChem();c++) {
 		dw1[c] = 0.; dw2[c] = 0.;
+    }
+}
 void MeinhardtPlugin::CellDynamics(CellBase *c, double *dchem) {
 	double Y = c->Chemical(0);
 	double A = c->Chemical(1);
 	double H = c->Chemical(2);
 	double S = c->Chemical(3);
 	//double expansin = c->Chemical(4);
     dchem[0] = ( par->d * A - par->e * Y + Y*Y/(1 + par->f * Y*Y ) );
 	dchem[1] = ( par->c * A*A*S/H - par->mu * A + par->rho0*Y );
 	dchem[2] = ( par->c * A*A*S - par->nu*H + par->rho1*Y );
 	dchem[3] = ( par->c0 - par->gamma*S - par->eps * Y * S );
 	//dchem[4] = ( -par->expansindecay * expansin );
 	//for (int i=0;i<4;i++) { cerr << "[ " << dchem[i] << " ]"; } cerr << endl;
 //	cerr << "Chemicals: "; for (int i=0;i<NChem();i++) { cerr << c->Chemical(i) << " "; } cerr << endl;
 // test:	dchem[0] = 0.01 * c->Chemical(0) * ( 1. - c->Chemical(0));
+}
 Q_EXPORT_PLUGIN2(meinhardtplugin, MeinhardtPlugin)

src/build_models/meinhardtplugin.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
  *  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.
+ *
  */
 #ifndef _MEINHARDTPLUGIN_H_
 #define _MEINHARDTPLUGIN_H_
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "simplugin.h"
+#include "../simplugin.h"
 class MeinhardtPlugin : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void) { return QString( "Meinhardt 1976, with growth" ); }
 	// Executed after the cellular mechanics steps have equillibrized
-	virtual void CellHouseKeeping (CellBase &c);
+	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
-	virtual void OnDivide(ParentInfo &parent_info, CellBase &daughter1, CellBase &daughter2);
+	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
-	virtual void SetCellColor(CellBase &c, QColor &color);
+	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void) { return 4; }
 };
 #endif

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 += -Llib -lvleaf
+ LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -Llib -lvleaf
+ 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_leaf.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 = leaf
 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 += -Llib -lvleaf
+ LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -Llib -lvleaf
+ 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 += -Llib -lvleaf
+ LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -Llib -lvleaf
+ 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 += -Llib -lvleaf
+ LIBS += -L$${LIBDIR} -lvleaf
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
+}
 win32 {
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  LIBS += -Llib -lvleaf
+ LIBS += -L$${LIBDIR} -Llib -lvleaf
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
 # finis

src/build_models/simplugin.h

➞

Show inline comments

deleted file

src/build_models/testplugin.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
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #include "testplugin.h"
 static const std::string _module_id("$Id$");
 bool batch = false;
 // To be executed after cell division
-void TestPlugin::OnDivide(ParentInfo &parent_info, CellBase &daughter1, CellBase &daughter2) {
+void TestPlugin::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
+}
-void TestPlugin::SetCellColor(CellBase &c, QColor &color) {
+void TestPlugin::SetCellColor(CellBase *c, QColor *color) {
 	static QStringList colors;
 	if (colors.size()==0) {
 		colors << "red" << "green" << "blue";
+	}
-	color = colors[c.Index()%colors.size()];
+	color->setNamedColor(colors[c->Index()%colors.size()]);
+}
-void TestPlugin::CellHouseKeeping(CellBase &c) {
+void TestPlugin::CellHouseKeeping(CellBase *c) {
 	c.EnlargeTargetArea(par->cell_expansion_rate);
 	if (c.Area() > par->rel_cell_div_threshold * c.BaseArea() ) {
 		c.Divide();
 	c->EnlargeTargetArea(par->cell_expansion_rate);
 	if (c->Area() > par->rel_cell_div_threshold * c->BaseArea() ) {
 		c->Divide();
+	}
+}
 void TestPlugin::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {}
 void TestPlugin::WallDynamics(Wall *w, double *dw1, double *dw2) {}
 void TestPlugin::CellDynamics(CellBase *c, double *dchem) { }
 Q_EXPORT_PLUGIN2(testplugin, TestPlugin)

src/build_models/testplugin.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
  *  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.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include <QString>
 #include "../simplugin.h"
 class TestPlugin : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void) { return QString( "Test model" ); }
 	// Executed after the cellular mechanics steps have equillibrized
-	virtual void CellHouseKeeping (CellBase &c);
+	virtual void CellHouseKeeping (CellBase *c);
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem);
 	// to be executed after a cell division
-	virtual void OnDivide(ParentInfo &parent_info, CellBase &daughter1, CellBase &daughter2);
+	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);
 	// to be executed for coloring a cell
-	virtual void SetCellColor(CellBase &c, QColor &color);
+	virtual void SetCellColor(CellBase *c, QColor *color);
 	// return number of chemicals
 	virtual int NChem(void) { return 0; }
 };

src/build_models/translate_plugin.pl

➞

Show inline comments

@@ new file 100755 @@
 #!/usr/bin/perl
 $cfilename = shift(@ARGV) || die "Usage: translate_plugin.pl [cfile] [hfile] [profile]\n";
 $hfilename = shift(@ARGV) || die "Usage: translate_plugin.pl [cfile] [hfile] [profile]\n";
 $pfilename = shift(@ARGV) || die "Usage: translate_plugin.pl [cfile] [hfile] [profile]\n";
 $ocfname = $cfilename; $ocfname =~ s/\.cpp/_tl.cpp/g;
 $ohfname = $hfilename; $ohfname =~ s/\.h/_tl.h/g;
 $opfname = $pfilename; $opfname =~ s/\.pro/_tl.pro/g;
 print STDERR "Translating '$cfilename' to '$ocfname', '$hfilename' to '$ohfname', and '$pfilename' to '$opfname'\n";
 open cfile,"<$cfilename";
 open ocfile,">$ocfname";
 while (<cfile>) {
 	#s/$hfilename/$ohfname/g;
 	# translate function definitions
 	if (/[a-zA-Z0-9 ]*::OnDivide/) {
 		s/ParentInfo &parent_info/ParentInfo *parent_info/g;
 		s/CellBase &daughter1/CellBase *daughter1/g;
 		s/CellBase &daughter2/CellBase *daughter2/g;
+	}
 	if (/[a-zA-Z0-9 ]*::SetCellColor/) {
 		s/CellBase &c/CellBase *c/g;
 		s/QColor &color/QColor *color/g;
+	}
 	if (/[a-zA-Z0-9 ]*::CellHouseKeeping/) {
 		s/CellBase &c/CellBase *c/g;
+	}
 	# translate member function calls
 	s/\bparent_info\b\./parent_info->/g;
 	s/\bdaughter1\b\./daughter1->/g;
 	s/\bdaughter2\b\./daughter2->/g;
 	s/\bc\b\./c->/g;
 	s/\bcolor\b\./color->/g;
 	print ocfile;
+}
 open hfile,"<$hfilename";
 open ohfile,">$ohfname";
 while (<hfile>) {
 	if (/[ \t]*virtual[ \t]+void[ \t]+CellHouseKeeping/) {
 		s/CellBase &c/CellBase *c/g;
+	}
 	if (/[ \t]*virtual[ \t]+void[ \t]+OnDivide/) {
 		s/ParentInfo &parent_info/ParentInfo *parent_info/g;
 		s/CellBase &daughter1/CellBase *daughter1/g;
 		s/CellBase &daughter2/CellBase *daughter2/g;
+	}
 	if (/[ \t]*virtual[ \t]+void[ \t]+SetCellColor/) {
 		s/CellBase &c/CellBase *c/g;
 		s/QColor &color/QColor *color/g;
+	}
 	print ohfile;
+}
 open pfile,"<$pfilename";
 open opfile,">$opfname";
 while (<pfile>) {
 	s/\bplugin\b\.h/plugin_tl\.h/g;
 	s/\bplugin\b\.cpp/plugin_tl\.cpp/g;
 	print opfile;
+}
@@ \ No newline at end of file @@

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
  *  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.
+ *
  */
 #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"
 #include <QDebug>
 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);
 		} // else {
 		//       //cerr << "cross.z * prev_cross_z = " << cross.z * prev_cross_z << endl;
 		//     }
 		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
 	cerr << "This is cell " << Index() << "\n";
 	cerr << "Number of walls: " << walls.size() << endl;
 	for (list<Wall *>::iterator w=walls.begin();
 		 w!=walls.end();
 		 w++) {
 		cerr << "Before apoptosis, wall " << (*w)->Index() << " says: c1 = " << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
+	}
 	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;
+		}
 		if (illegal_flag && (*w)->c1==(*w)->c2) {
 			cerr << "I created an illegal wall.\n";
+		}
 		if ( ((*w)->N1()->DeadP() || (*w)->N2()->DeadP()) ||
 			((*w)->C1() == (*w)->C2() ) ){
 			// kill wall
 			cerr << "Killing wall.\n";
 			(*w)->Kill();
 			if ((*w)) {
 				cerr << "Wall " << (*w)->Index() << " says: c1 = " << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
+			}
 			(*w)=0;
 		} else {
 			cerr << "Not killing wall.\n";
 			cerr << "Wall " << (*w)->Index() << " says: c1 = " << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
+		}
+	}
 	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);
+			}
+		}
+	}
 	/*
 	 // correct boundary polygon if this cell touches the boundary
 	 // find the first living boundary node after a dead node
 	 bool node_found = false;
 	 for (list<Node *>::iterator n=nodes.begin();
 	 n!=nodes.end();
 	 n++) {
 	 Node &no(*(*n));
 	 if (no.DeadP()) {
 	 list<Node *>::iterator first_node = n;
 	 if (++next_node == nodes.end()) first_node=nodes.begin();
 	 if (!(*(*first_node)).DeadP() && ((*first_node)->boundary)) {
 	 node_found=true;
 	 break;
+	 }
+	 }
+	 }
 	 // locate it in the boundary_polygon
 	 if (node_found) {
 	 list<Node *>::iterator insert_it = find(mesh->boundary_polygon->nodes.begin(),
 	 mesh->boundary_polygon->nodes.end(),
 	 ++first_node);
 	 if (insert_it!=owners.end()) {
 	 if (insert_it==owners.end()) insert_it=owners.begin();
 	 for (list<Node *>::iterator n=insert_it;
 	 n!=nodes.end();
 	 n++) {
 	 Node &no(*(*n));
 	 mesh->boundary_polygon->nodes.insert(
+	 }
+	 }
 	 } */
 	// 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;
+		}
 		//cerr << "[" << *i << "]";
 		//if (*i==10 || *i==11) {
 		//cerr << "previous = " << previous << ", next = " << next << endl;
 		//}
 		//if (*i!=10 && *i!=11)
 		//cerr << "Node " << *i << endl << " = " << *(*i) << endl;
 		(*i)->owners.push_back( Neighbor( this, previous, next ) );
 		// if (*i==50 || *i==51) {
 		//cerr << "Node " << *i << ".size() = " << (*i)->owners.size() << endl;
 		// }
+    }
+}
 /*! \brief Divide the cell over the line v1-v2.
  \param v1: First vertex of line.
  \param v2: Second vertex of line.
  \param fixed_wall: If true: wall will be set to "fixed" (i.e. not motile)
  \return: true if the cell divided, false if not (i.e. no intersection between v1 and v2, and the cell)
  */
 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;
 	cerr << "Cell " << Index() << " is doing DivideOverGivenLine \n";
 	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;
 		/* double intersec_x = v1.x + ua*(v2.x-v1.x);
 		 double intersec_y = v1.y + ua*(v2.y-v1.y);*/
 		//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);
+		}
+	}
 	if (new_node_locations.size()<2) {
 		cerr << "Line does not intersect with two edges of Cell " << Index() << endl;
 		cerr << "new_node_locations.size() = " << new_node_locations.size() << endl;
 		return false;
+	}
 	ItList::iterator i = new_node_locations.begin();
 	list< Node *>::iterator j;
 	cerr << "-------------------------------\n";
 	cerr << "Location of new nodes: " << (**i)->Index() << " and ";
 	++i;
 	j = *i;
 	if (j==nodes.begin()) j=nodes.end(); j--;
 	cerr << (*j)->Index() << endl;
 	cerr << "-------------------------------\n";
 	if ( **new_node_locations.begin() == *j ) {
 		cerr << "Rejecting proposed division (cutting off zero area).\n";
 		return false;
+	}
 	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;
 	//extern double auxin_account;
 	//auxin_account += daughter->chem[0];
 	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;
 //	daughter->BaseArea()  = base_area;
 	// 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)
 		cerr << "new_node_locations.size() = " << new_node_locations.size() <<endl;
 		cerr << "daughter->index = " << daughter->index << endl;
 		cerr << "cells.size() = " << m->cells.size() << endl;
 		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];
 	Node *new_node_ind[2];
 	int new_node_flag[2];
 	Edge div_edges[2];
 	int nnc=0;
 	Wall *div_wall[4];
 	double orig_length[2];
 	for (int i=0;i<4;i++) { div_wall[i]=0; orig_length[i/2] = 0.; }
 	// construct new Nodes at the intersection points
 	// unless they coincide with existing points
 	for ( ItList::const_iterator i=new_node_locations.begin();
 		 i!=new_node_locations.end();
 		 i++) {
 		// intersection between division axis
 		// and line from this node to its predecessor
 		// method used: http://astronomy.swin.edu.au/~pbourke/geometry/lineline2d/
 		Vector v1 = from;
 		Vector v2 = to;
 		Vector v3 = *(**i);
 		// get previous node
 		list<Node *>::iterator nb=*i;
 		if (nb == nodes.begin()) {
 			nb = nodes.end();
+		}
 		nb--;
 		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 intersec_x = v1.x + ua*(v2.x-v1.x);
 		double intersec_y = v1.y + ua*(v2.y-v1.y);
 		// construct a new node at intersec
 		// we construct a vector temporarily,
 		// until we are sure we are going to keep the node...
 		// Node count is damaged if we construct superfluous nodes
 		Vector *n=new Vector(intersec_x,intersec_y,0);
 		div_edges[nnc].first=*nb;
 		div_edges[nnc].second=**i;
 		// Insert this new Node if it is far enough (5% of element length)
 		// from one of the two existing nodes, else use existing node
 		//
 		// old, fixed value was: par.collapse_node_threshold = 0.05
 		double collapse_node_threshold = 0.05;
 #ifdef FLEMING
 		collapse_node_threshold = par.collapse_node_threshold;
 #endif
 		double elem_length = ( (*(**i)) - (*(*nb)) ).Norm();
 		if ( ( *(**i) - *n ).Norm() < collapse_node_threshold  * elem_length ) {
 			new_node_flag[nnc]=1;
 			new_node[nnc] = *(**i);
 			new_node_ind[nnc] = **i;
 			//cerr << **i << "\n" ;
 		} else
 			if ( (*(*nb) - *n).Norm() < collapse_node_threshold * elem_length ) {
 				new_node_flag[nnc]=2;
 				new_node[nnc] = *(*nb);
 				new_node_ind[nnc] = *nb;
 			} else {
 				new_node_flag[nnc]=0;
 				new_node[nnc] = *n;
+			}
 		nnc++;
 		delete n;
+	}
 	for (int i=0;i<2;i++) {
 		Cell *neighbor_cell=0; // we need this to split up the "Wall" objects.
 		// for both divided edges:
 		//      insert its new node into all cells that own the divided edge
 		// but only if it really is a new node:
 		if (new_node_flag[i]!=0) {
 			if (fix_cellwall) {
 				(new_node_ind[i])->fixed = true;
 				// all this we'll do later for the node set :-)
 				/* (new_node_ind[i])->boundary = true;
 				 (new_node_ind[i])->sam = true;
 				 boundary = SAM;
 				 daughter->boundary = SAM;
 				 boundary_touched_flag = true;
 				 */
+			}
 		} else {
 			// (Construct a list of all owners:)
 			// really construct the new node (if this is a new node)
 			new_node_ind[i] =
 			m->AddNode(new Node (new_node[i]) );
 			// if a new node is inserted into a fixed edge (i.e. in the petiole)
 			// make the new node fixed as well
 			(new_node_ind[i])->fixed = (div_edges[i].first)->fixed &&
 			(div_edges[i].second)->fixed;
 			// Insert Node into NodeSet if the div_edge is part of it.
 			if (
 				(div_edges[i].first->node_set && div_edges[i].second->node_set) &&
 				(div_edges[i].first->node_set == div_edges[i].second->node_set))
+			{
 				//cerr << "Inserting node into node set\n";
 				div_edges[i].first->node_set->AddNode( new_node_ind[i] );
+			}
 			// if the new wall should be fixed (i.e. immobile, or moving as
 			// solid body), make it so, and make it part of the boundary. Using
 			// this to make a nice initial condition by cutting off part of a
 			// growing leaf.
 			if (fix_cellwall) {
 				(new_node_ind[i])->fixed = true;
 				// All this we'll do later for the node set only
 				/* (new_node_ind[i])->boundary = true;
 				 (new_node_ind[i])->sam = true;
 				 boundary_touched_flag = true;
 				 boundary = SAM;
 				 daughter->boundary = SAM;*/
+			}
 			// if new node is inserted into the boundary
 			// it will be part of the boundary, too
 			new_node_ind[i]->UnsetBoundary();
 			if ((div_edges[i].first->BoundaryP() && div_edges[i].second->BoundaryP()) && // Both edge nodes are boundary nodes AND
 			     ((m->findNextBoundaryNode(div_edges[i].first))->Index() == div_edges[i].second->Index())){ // The boundary proceeds from first to second.
                                 #ifdef QDEBUG
 			        qDebug() << "Index of the first node: " << div_edges[i].first->Index() << endl;
 			        qDebug() << "Index of the second node: " << div_edges[i].second->Index() << endl;
 			        qDebug() << "Boundary proceeds from: " <<  div_edges[i].first->Index()
 				         << "to: " << (m->findNextBoundaryNode(div_edges[i].first))->Index() << endl << endl;
                                 #endif
 			        new_node_ind[i]->SetBoundary();
 				// We will need to repair the boundary polygon later, since we will insert new nodes
 				//cerr << "Boundary touched for Node " << new_node_ind[i]->Index() << "\n";
 				boundary_touched_flag=true;
 				// and insert it into the boundary_polygon
 				// find the position of the first node in the boundary
 				list<Node *>::iterator ins_pos = find
 				(m->boundary_polygon->nodes.begin(),
 				 m->boundary_polygon->nodes.end(),
 				 div_edges[i].first);
 				// ... second node comes before or after it ...
 				if (*(++ins_pos!=m->boundary_polygon->nodes.end()?
 					  ins_pos:m->boundary_polygon->nodes.begin())!=div_edges[i].second) {
 					m->boundary_polygon->nodes.insert(((ins_pos--)!=m->boundary_polygon->nodes.begin()?ins_pos:(--m->boundary_polygon->nodes.end())), new_node_ind[i]);
 					// .. set the neighbors of the new node ...
 					// in this case e.second and e.first are inverted
 				} else {
 					// insert before second node, so leave ins_pos as it is,
 					// that is: incremented
 					m->boundary_polygon->nodes.insert(ins_pos, new_node_ind[i]);
 					// .. set the neighbors of the new node ...
+				}
+			}
 			list<Neighbor> owners;
 			// push all cells owning the two nodes of the divides edges
 			// onto a list
 			copy((div_edges[i].first)->owners.begin(),
 				 (div_edges[i].first)->owners.end(),
 				 back_inserter(owners));
 			copy((div_edges[i].second)->owners.begin(),
 				 (div_edges[i].second)->owners.end(),
 				 back_inserter(owners));
 			// find first non-self duplicate in the owners:
 			// cells owning the same two nodes
 			// share an edge with me
 			owners.sort( mem_fun_ref( &Neighbor::Cmp ) );
                         #ifdef QDEBUG
 			list<Neighbor> unique_owners;
 			copy(owners.begin(), owners.end(), back_inserter(unique_owners));
 			unique_owners.unique( mem_fun_ref( &Neighbor::Eq ) );
 			qDebug() << "The dividing edge nodes: " << div_edges[i].first->Index() << " and " << div_edges[i].second->Index() << " are owned by cells: ";
 			// spit out each owners' cell index
 			foreach(Neighbor neighbor, unique_owners){
 			  qDebug() << neighbor.cell->Index() << "  ";
+			}
 			qDebug() << endl;
                         #endif
 			// Search through the sorted list of edge node owners looking for duplicate pairs. Each pair represents an actual edge owner.
 			list<Neighbor> edge_owners;
 			list<Neighbor>::iterator it;
 			for (it=owners.begin(); it!=owners.end(); it++) {
 			  it = adjacent_find(it, owners.end(), neighbor_cell_eq);
 			  if (it == owners.end()) break; // bail if reach the end of the list
                           #ifdef QDEBUG
 			  qDebug() << "Considering: " << it->cell->Index() << " as a possible edge owner." << endl;
                           #endif
 			  if (it->cell->Index() != this->Index()) {
                             #ifdef QDEBUG
 			    qDebug() << "Adding: " << it->cell->Index() << " to the list of edge owners." << endl;
                             #endif
 			    edge_owners.push_back(*it);
+			  }
+			}
 			if (edge_owners.size() > 1){
 			  // Remove the boundary polygon - if its there
 			  list<Neighbor>::iterator it;
 			  if ((it = find_if (edge_owners.begin(), edge_owners.end(), bind2nd(mem_fun_ref(&Neighbor::CellEquals), -1))) != edge_owners.end()) {
                             #ifdef QDEBUG
 			    qDebug() << "deleating: " << it->cell->Index() << " from the list of edge owners." << endl;
                             #endif
 			    edge_owners.erase(it);
+			  }
+			}
                         #ifdef QDEBUG
 			qDebug() << "The edge owners list has: " << edge_owners.size() << " elements" << endl;
 			#endif
 			// Since the list should always contain exactly one element, pass it on as an iterator
 			list<Neighbor>::iterator c = (edge_owners.size() != 0) ? edge_owners.begin() : edge_owners.end();
 			// (can we have more than one neighboring cell here??)
 			if (c!=owners.end()) {
 				neighbor_cell = c->cell;
 				if (!c->cell->BoundaryPolP()) {
 					// find correct position in the cells node list
 					// to insert the new node
 					list<Node *>::iterator ins_pos = find
 					(neighbor_cell->nodes.begin(),
 					 neighbor_cell->nodes.end(),
 					 div_edges[i].first);
 					neighbor_cell->nodes.insert(ins_pos, new_node_ind[i]);
 					neighbor_cell->ConstructConnections();
 					// give walls to daughter later
+			  }
 			} else {
 				neighbor_cell = 0;
+			}
+		}
 		// Split the Wall with the neighboring cell
 		// if the neighbor cell has not yet been identified above, do it now
 		if (neighbor_cell == 0) {
 			list<Neighbor> owners;
 			// push all cells owning the two nodes of the divides edges
 			// onto a list
 			copy((div_edges[i].first)->owners.begin(),
 				 (div_edges[i].first)->owners.end(),
 				 back_inserter(owners));
 			copy((div_edges[i].second)->owners.begin(),
 				 (div_edges[i].second)->owners.end(),
 				 back_inserter(owners));
 			// find first non-self duplicate in the owners:
 			// cells owning the same two nodes
 			// share an edge with me
 			owners.sort( mem_fun_ref( &Neighbor::Cmp ) );
 			list<Neighbor>::iterator c;
 			for (c=owners.begin();
 				 c!=owners.end();
 				 c++) {
 				c=adjacent_find(c,owners.end(),neighbor_cell_eq);
 				if (c->cell->Index() != this->Index() || c==owners.end()) break;
+			}
 			if (c!=owners.end())
 				neighbor_cell = c->cell;
 			else
 				neighbor_cell = 0;
+		}
 		if (neighbor_cell /* && !neighbor_cell->BoundaryPolP() */) {
 			//cerr << "Cell "  << index << " says: neighboring cell is " << neighbor_cell->index << endl;
 			/*************** 1. Find the correct wall element  ********************/
 			list<Wall *>::iterator w, start_search;
 			w = start_search = walls.begin();
 			do {
 				// Find wall between this cell and neighbor cell
 				w = find_if( start_search, walls.end(), bind2nd (mem_fun( &Wall::is_wall_of_cell_p ), neighbor_cell ) );
 				start_search = w; start_search++; // continue searching at next element
 			} while ( w!=walls.end() && !(*w)->IntersectsWithDivisionPlaneP( from, to ) ); // go on until we find the right one.
 			if (w == walls.end()) {
 				cerr << "Whoops, wall element not found...!\n";
 				cerr << "Cell ID: " << neighbor_cell->Index() << endl;
 				cerr << "My cell ID: " << Index() << endl;
 			} else {
 				// 2. Split it up, if we should (sometimes, the new node coincides with an existing node so
 				// we should not split up the Wall)
 				if (new_node_ind[i]!=(*w)->n1 && new_node_ind[i]!=(*w)->n2) {
 					Wall *new_wall;
 					// keep the length of the original wall; we need it to equally divide the transporter concentrations
 					// over the two daughter walls
 					(*w)->SetLength(); // make sure we've got the current length
 					orig_length[i] = (*w)->Length();
 					//cerr << "Original length is " << orig_length[i] << endl;
 					if ((*w)->c1 == this ) {
 						//  cerr << "Cell " << (*w)->c1->Index() << " splits up wall " << *(*w) << ", into: " << endl;
 						new_wall = new Wall( (*w)->n1, new_node_ind[i], this, neighbor_cell);
 						(*w)->n1 = new_node_ind[i];
 						//  cerr << "wall " << *(*w) << ", and new wall " << *new_wall << endl;
 					} else {
 						new_wall = new Wall( (*w)->n1, new_node_ind[i], neighbor_cell, this);
 						(*w)->n1 = new_node_ind[i];
+					}
 					//new_wall->ResetTransporterConcentrations(orig_length);
 					//(*w)->ResetTransporterConcentrations(orig_length);
 					// reset the transporter concentrations
 					/*	  new_wall->SetLength();
 					 new_wall->CorrectLength(orig_length);
 					 (*w)->SetLength();
 					 (*w)->CorrectLength(orig_length);*/
 					// 3. Give wall elements to appropriate cells
 					if (new_wall->n1 != new_wall->n2) {
 						if (par.copy_wall)
 							new_wall->CopyWallContents(**w);
 						else {
 							// If wall contents are not copied, decide randomly which wall will be the "parent"
 							// otherwise we will get biases (to the left), for example in the meristem growth model
 							if (RANDOM()<0.5) {
 								new_wall->SwapWallContents(*w);
+							}
+						}
 						AddWall(new_wall);
 						// cerr << "Building new wall: this=" << Index() << ", neighbor_cell = " << neighbor_cell->Index() << endl;
 						neighbor_cell->AddWall( new_wall);
 						//cerr << "Existing wall: c1 = " << (*w)->c1->Index() << ", neighbor_cell = " << (*w)->c2->Index() << endl;
 						// Remember the addresses of the new walls
 						div_wall[2*i+0] = *w;
 						div_wall[2*i+1] = new_wall;
 						// we will correct the transporter concentrations later in this member function, after division
 						// First the new nodes should be inserted into the cells, before we can calculate wall lengths
 						// Remember that cell walls can be bent, so have a bigger length than the Euclidean distance n1->n2
 					} else {
 						delete new_wall;
+					}
+				}
+			}
+		}
 	}  // closing loop over the two divided edges (for (int i=0;i<2;i++) )
 	// move half of the nodes to the daughter
+	{
 		//cerr << "Daughter: ";
 		list<Node *>::iterator start, stop;
 		start=new_node_locations.front();
 		//cerr << "*new_node_locations.front() = " << *new_node_locations.front() << endl;
 		if (new_node_flag[0]==1) {
 			start++;
 			if (start==nodes.end())
 				start=nodes.begin();
+		}
 		stop=new_node_locations.back();
 		if (new_node_flag[1]==2) {
 			if (stop==nodes.begin())
 				stop=nodes.end();
 			stop--;
+		}
 		list<Node *>::iterator i=start;
 		while ( i!=stop) {
 			// give the node to the daughter
 			// (find references to parent cell from this node,
 			// and remove them)
 			list<Neighbor>::iterator neighb_with_this_cell=
 			find_if((*i)->owners.begin(),
 					(*i)->owners.end(),
 				bind2nd(mem_fun_ref( &Neighbor::CellEquals ),this->Index() )  );
 			if (neighb_with_this_cell==(*i)->owners.end()) {
 				cerr << "not found\n";
 				abort();
+			}
 			(*i)->owners.erase(neighb_with_this_cell);
 			daughter->nodes.push_back( *i );
 			i++;
 			if (i==nodes.end())
 				i=nodes.begin();
 		};
+	}
 	// new node list of parent
 	list<Node *> new_nodes_parent;
 	// half of the nodes stay with the parent
+	{
 		list<Node *>::iterator start, stop;
 		start=new_node_locations.back();
 		if (new_node_flag[1]==1) {
 			start++;
 			if (start==nodes.end())
 				start=nodes.begin();
+		}
 		stop=new_node_locations.front();
 		if (new_node_flag[0]==2) {
 			if (stop==nodes.begin())
 				stop=nodes.end();
 			stop--;
+		}
 		list<Node *>::iterator i=start;
 		while (i!=stop) {
 			new_nodes_parent.push_back( *i );
 			i++;
 			if (i==nodes.end())
 				i = nodes.begin();
 		};
+	}
 	// insert shared wall
 	// insert shared nodes on surface of parent cell
 	new_nodes_parent.push_back( new_node_ind[0] );
 	daughter->nodes.push_back ( new_node_ind[1] );
 	// optionally add the new node to the nodeset (passed by pointer)
 	// (in this way we can move the NodeSet as a whole; useful for a fixed cutting line)
 	if (node_set) {
 		node_set->AddNode( new_node_ind[0] );
+	}
 #define MULTIPLE_NODES
 #ifdef MULTIPLE_NODES
 	// intermediate, extra nodes
 	// Calculate distance between the two new nodes
 	double dist=( new_node[1] - new_node[0] ).Norm();
 	//bool fixed_wall = (new_node_ind[0])->fixed && (new_node_ind[1])->fixed;
 	bool fixed_wall = false;
 	// Estimate number of extra nodes in wall
 	// factor 4 is to keep tension on the walls;
 	// this is a hidden parameter and should be made explicit
 	// later on.
 	int n=(int)((dist/Node::target_length)/4+0.5);
 	Vector nodevec = ( new_node[1]- new_node[0]).Normalised();
 	double element_length = dist/(double)(n+1);
 	// note that wall nodes need to run in inverse order in parent
 	list<Node *>::iterator ins_pos = daughter->nodes.end();
 	for (int i=1;i<=n;i++) {
 		Node *node=
 		m->AddNode( new Node( new_node[0] + i*element_length*nodevec ) );
 		node->fixed=fixed_wall;
 		if (!fix_cellwall)
 			node->boundary = false;
 		else { // if fix_cellwall is true, that is if we are cutting off
 			// part of a leaf to make a nice initial condition, we also want to make it part of the boundary
 			//node->boundary = true;
 			node->fixed = true;
 			//node->sam = true;
+		}
 		ins_pos=daughter->nodes.insert(ins_pos, node );
 		new_nodes_parent.push_back( node );
 		// optionally add the new node to the nodeset (passed by pointer)
 		// (in this way we can move the NodeSet as a whole; useful for a fixed cutting line)
 		if (node_set) {
 			node_set->AddNode( node );
+		}
+	}
 #endif
 	daughter->nodes.push_back( new_node_ind[0] );
 	new_nodes_parent.push_back( new_node_ind[1] );
 	// optionally add the new node to the nodeset (passed by pointer)
 	// (in this way we can move the NodeSet as a whole; useful for a fixed cutting line)
 	if (node_set) {
 		node_set->AddNode( new_node_ind[1] );
+	}
 	// move the new nodes to the parent
 	nodes.clear();
 	copy( new_nodes_parent.begin(),
 		 new_nodes_parent.end(),
 		 back_inserter(nodes) );
 	// Repair cell lists of Nodes, and node connectivities
 	ConstructConnections();
 	daughter->ConstructConnections();
 	if (boundary_touched_flag) {
 		m->boundary_polygon->ConstructConnections();
+	}
 	// collecting neighbors of divided cell
 	list<CellBase *> broken_neighbors;
 	// this cell's old neighbors
 	copy(neighbors.begin(), neighbors.end(), back_inserter(broken_neighbors) );
 	// this cell
 	broken_neighbors.push_back(this);
 	// its daughter
 	broken_neighbors.push_back(daughter);
 	// Recalculate area of parent and daughter
 	area = CalcArea();
 	daughter->area = daughter->CalcArea();
 	SetIntegrals();
 	daughter->SetIntegrals();
 	// Add a "Cell Wall" for diffusion algorithms
 	Wall *wall = new Wall( new_node_ind[0], new_node_ind[1], this, daughter );
 	AddWall( wall );
 	daughter->AddWall( wall );
 	//cerr << "Correct walls of cell " << Index() << " and daughter " << daughter->Index() << endl;
 	// Move Walls to daughter cell
 	list <Wall *> copy_walls = walls;
 	for (list<Wall *>::iterator w = copy_walls.begin();
 		 w!=copy_walls.end();
 		 w++) {
 		//cerr << "Doing wall, before:  " << **w << endl;
 		//  checks the nodes of the wall and gives it away if appropriate
 		(*w)->CorrectWall ( );
 		//cerr << "and after: " << **w << endl;
+	}
 	// Correct tranporterconcentrations of divided walls
 	for (int i=0;i<4;i++) {
 		if (div_wall[i]) {
 			div_wall[i]->SetLength();
 			div_wall[i]->CorrectTransporters(orig_length[i/2]);
+		}
+	}
 	//neighbors.push_back( daughter );
 	//daughter->neighbors.push_back( this );
 	//cerr << "Cell " << index << " has been dividing, and gave birth to Cell " << daughter->index << endl;
 	// now reconstruct neighbor list for all "broken" neighbors
 	for (list<CellBase *>::iterator i=broken_neighbors.begin();
 		 i!=broken_neighbors.end();i++) {
 		((Cell *)(*i))->ConstructNeighborList();
+	}
 	ConstructNeighborList();
 	daughter->ConstructNeighborList();
-	m->plugin->OnDivide(parent_info,*daughter, *this);
+	m->plugin->OnDivide(&parent_info, daughter, this);
 	// wall->OnWallInsert();
 	//daughter->OnDivide();
 	daughter->div_counter=(++div_counter);
+}
 // Move the whole cell
 void Cell::Move(const Vector T) {
     for (list<Node *>::const_iterator i=nodes.begin();
 		 i!=nodes.end();
 		 i++) {
 		*(*i)+=T;
+    }
+}
 double Cell::Displace(double dx, double dy, double dh) {
 	// Displace whole cell, add resulting energy to dh,
 	// and accept displacement if energetically favorable
 	//
 	// Method is called if a "fixed" node is displaced
 	// Warning: length constraint not yet  CORRECTLY implemented for this function
 	// Attempt to move this cell in a random direction
 	//  Vector movement(par.mc_cell_stepsize*(RANDOM()-0.5),par.mc_cell_stepsize*(RANDOM()-0.5),0);
 	dh=0;
 	Vector movement(dx,dy,0);
 	vector< pair<Node *, Node *> > length_edges;
 	vector<double> cellareas;
 	cellareas.reserve(neighbors.size());
 	// for the length constraint, collect all edges to this cell's nodes,
 	// which are not part of the cell
 	// the length of these edges will change
 	double old_length=0.;
 	for (list<Node *>::const_iterator i=nodes.begin();
 		 i!=nodes.end();
 		 i++) {
 		//if ((*i)->Fixed()) return; // commented out 01/12/05
 		for (list<Neighbor>::const_iterator n=(*i)->owners.begin();
 			 n!=(*i)->owners.end();
 			 n++) {
 			if (n->getCell()!=this) {
 				//if (!(m->getNode(n->nb1).Fixed() && m->getNode(n->nb2).Fixed())) {
 				length_edges.push_back( pair <Node *,Node *> (*i, n->nb1) );
 				length_edges.push_back( pair <Node *,Node *> (*i, n->nb2) );
 				old_length +=
 				DSQR(Node::target_length-(*(*i)-*(n->nb1)).Norm())+
 				DSQR(Node::target_length-(*(*i)-*(n->nb2)).Norm());
 				//}
+			}
+		}
+	}
 	// calculate area energy difference of neighboring cells
 	// (this cells' shape remains unchanged)
 	double old_area_energy=0., old_length_energy=0.;
 	for (list<CellBase *>::const_iterator i=neighbors.begin();
 		 i!=neighbors.end();
 		 i++) {
 		old_area_energy += DSQR((*i)->Area()-(*i)->TargetArea());
 		old_length_energy += DSQR((*i)->Length()-(*i)->TargetLength());
+	}
 	Move(movement);
 	double new_area_energy=0., new_length_energy=0.;
 	for (list<CellBase *>::const_iterator i=neighbors.begin();
 		 i!=neighbors.end();
 		 i++) {
 		cellareas.push_back((*i)->CalcArea());
 		new_area_energy += DSQR(cellareas.back()-(*i)->TargetArea());
 		new_length_energy += DSQR((*i)->CalcLength()-(*i)->TargetLength());
+	}
 	double new_length=0;
 	for ( vector< pair< Node *, Node * > >::const_iterator e = length_edges.begin();
 		 e != length_edges.end();
 		 e++) {
 		new_length +=  DSQR(Node::target_length-
 							(*(e->first)-*(e->second)).Norm());
+	}
 	dh += (new_area_energy - old_area_energy) + (new_length_energy - old_length_energy) * lambda_celllength +
 	par.lambda_length * (new_length - old_length);
 	if (dh<0 || RANDOM()<exp(-dh/par.T)) {
 		// update areas of cells
 		//cerr << "neighbors: ";
 		list<CellBase *>::const_iterator nb_it = neighbors.begin();
 		for (vector<double>::const_iterator ar_it = cellareas.begin();
 			 ar_it!=cellareas.end();
 			 ( ar_it++, nb_it++) ) {
 			((Cell *)(*nb_it))->area = *ar_it;
 			(*nb_it)->SetIntegrals();
+		}
 		//cerr << endl;
 		/*vector<double> area1;
 		 vector<double> area2;
 		 m->ExtractFromCells( mem_fun_ref(&Cell::Area), back_inserter(area1) );
 		 m->ExtractFromCells( mem_fun_ref(&Cell::CalcArea), back_inserter(area2));
 		 vector<double>::iterator i=area1.begin();
 		 vector<double>::iterator j=area2.begin();
 		 int c=0;
 		 for (;
 		 i!=area1.end();
 		 (i++, j++)) {
 		 if ( (*i-*j) > 1e-10) {
 		 cerr << c++ << " " << *i << " " << *j << endl;
 		 abort();
+		 }
 		 }*/
 	} else {
 		Move ( -1*movement);
+	}
 	return dh;
+}
 void Cell::Displace (void) {
 	Displace(par.mc_cell_stepsize*(RANDOM()-0.5),par.mc_cell_stepsize*(RANDOM()-0.5),0);
+}
 // Get energy level of whole cell (excluding length constraint?)
 double Cell::Energy(void) const {
 	double energy = 0.;
 	double length_contribution = 0.;
 	for (list<Node *>::const_iterator i=nodes.begin();
 		 i!=nodes.end();
 		 i++) {
 		for (list<Neighbor>::const_iterator n=(*i)->owners.begin();
 			 n!=(*i)->owners.end();
 			 n++) {
 			if (n->getCell()==this) {
 				length_contribution +=
 				DSQR(Node::target_length-(*(*i)-*(n->nb1)).Norm())+
 				DSQR(Node::target_length-(*(*i)-*(n->nb2)).Norm());
+			}
+		}
+	}
 	// wall elasticity constraint
 	energy += par.lambda_length * length_contribution;
 	// area constraint
 	energy += DSQR(CalcArea() - target_area);
 	// cell length constraint
 	energy += lambda_celllength * DSQR(Length() - target_length);
 	return energy;
+}
 bool Cell::SelfIntersect(void) {
     // The (obvious) O(N*N) algorithm
     // Compare each edge against each other edge
     // An O(N log(N)) algorithm by Shamos & Hoey (1976) supposedly exists;
     // it was mentioned on comp.graphics.algorithms
     // But I haven't been able to lay my hand on the paper.
     // Let's try whether we need it....
     // method used: http://astronomy.swin.edu.au/~pbourke/geometry/lineline2d/
     for (list<Node *>::const_iterator i=nodes.begin();
 		 i!=nodes.end();
 		 i++) {
 		list<Node *>::const_iterator j=i;
 		++j;
 		for (;
 			 j!=nodes.end();
 			 j++)
+		{
 			Vector v1 = *(*i);
 			list<Node *>::const_iterator nb=i;
 			nb++;
 			if (nb == nodes.end()) {
 				nb = nodes.begin();
+			}
 			Vector v2 = *(*nb);
 			Vector v3 = *(*j);
 			nb=j;
 			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;
 			/* double intersec_x = v1.x + ua*(v2.x-v1.x);
 			 double intersec_y = v1.y + ua*(v2.y-v1.y);*/
 			if ( ( TINY < ua && ua < 1.-TINY ) && ( TINY < ub && ub < 1.-TINY ) ) {
 				//cerr << "ua = " << ua << ", ub = " << ub << endl;
 				return true;
+			}
+		}
+    }
     return false;
+}
 bool Cell::MoveSelfIntersectsP(Node *moving_node_ind, Vector new_pos) {
 	// Check whether the polygon will self-intersect if moving_node_ind
 	// were displaced to new_pos
 	// Compare the two new edges against each other edge
 	// O(2*N)
 	// method used for segment intersection:
 	// http://astronomy.swin.edu.au/~pbourke/geometry/lineline2d/
 	Vector neighbor_of_moving_node[2];
 	//cerr << "list<Node *>::const_iterator moving_node_ind_pos = find (nodes.begin(),nodes.end(),moving_node_ind);\n";
 	list<Node *>::const_iterator moving_node_ind_pos = find (nodes.begin(),nodes.end(),moving_node_ind);
 	list<Node *>::const_iterator nb = moving_node_ind_pos;
 	//cerr << "Done\n";
 	nb++;
 	if (nb == nodes.end()) {
 		nb = nodes.begin();
+	}
 	neighbor_of_moving_node[0]=*(*nb);
 	nb=moving_node_ind_pos;
 	if (nb == nodes.begin()) {
 		nb = nodes.end();
+	}
 	nb--;
 	neighbor_of_moving_node[1]=*( *nb );
 	for (list<Node *>::const_iterator i=nodes.begin();
 		 i!=nodes.end();
 		 i++) {
 		for (int j=0;j<2;j++) { // loop over the two neighbors of moving node
 			list<Node *>::const_iterator nb=i;
 			nb++;
 			if (nb == nodes.end()) {
 				nb = nodes.begin();
+			}
 			if (*i == moving_node_ind || *nb == moving_node_ind) {
 				// do not compare to self
 				continue;
+			}
 			Vector v3 = *(*i);
 			Vector v4 = *(*nb);
 			double denominator =
 			(v4.y - v3.y)*(neighbor_of_moving_node[j].x - new_pos.x) - (v4.x - v3.x)*(neighbor_of_moving_node[j].y - new_pos.y);
 			double ua =
 			((v4.x - v3.x)*(new_pos.y - v3.y) - (v4.y - v3.y)*(new_pos.x -v3.x))/denominator;
 			double ub =
 			((neighbor_of_moving_node[j].x - new_pos.x)*(new_pos.y-v3.y) - (neighbor_of_moving_node[j].y- new_pos.y)*(new_pos.x - v3.x))/denominator;
 			/* double intersec_x = new_pos.x + ua*(neighbor_of_moving_node[j].x-new_pos.x);
 			 double intersec_y = new_pos.y + ua*(neighbor_of_moving_node[j].y-new_pos.y);*/
 			if ( ( TINY < ua && ua < 1.-TINY ) && ( TINY < ub && ub < 1.-TINY ) ) {
 				//cerr << "ua = " << ua << ", ub = " << ub << endl;
 				return true;
+			}
+		}
+	}
 	return false;
+}
 /*! \brief Test if this cell intersects with the given line.
  */
 bool Cell::IntersectsWithLineP(const Vector v1, const Vector v2) {
 	// Compare the line against each edge
 	// method used: http://astronomy.swin.edu.au/~pbourke/geometry/lineline2d/
 	for (list<Node *>::const_iterator i=nodes.begin();
 		 i!=nodes.end();
 		 i++)
+    {
 		Vector v3 = *(*i);
 		list<Node *>::const_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;
 		/* double intersec_x = v1.x + ua*(v2.x-v1.x);
 		 double intersec_y = v1.y + ua*(v2.y-v1.y);*/
 		if ( ( TINY < ua && ua < 1.-TINY ) && ( TINY < ub && ub < 1.-TINY ) ) {
 			return true;
+		}
+    }
 	return false;
+}
 /*! \brief Constructs Walls, but only one per cell boundary.
  Standard method constructs a Wall for each cell wall element,
  making transport algorithms computationally more intensive than needed.
  We can remove this? Well, let's leave it in the code in case we need it for something else. E.g. for importing leaf architectures in different formats than our own... :-)
  */
 void Cell::ConstructWalls(void) {
 	return;
 	if (dead) return;
 	walls.clear();
 	neighbors.clear();
 	// Get "corner points; i.e. nodes where more than 2 cells are connected
 	list<Node *> corner_points;
 	for (list<Node *>::const_iterator i=nodes.begin();
 		 i!=nodes.end();i++) {
 		// look for nodes belonging to >2 cells
 		if ((*i)->owners.size()>2) {
 			// push onto list
 			corner_points.push_back(*i);
+		}
+	}
 	// Construct Walls between corner points
 	// previous one in list
 	list<Node *>::const_iterator nb = (--corner_points.end());
 	// loop over list,
 	for (list<Node *>::const_iterator i=corner_points.begin();
 		 i!=corner_points.end(); ( i++, nb++) ) {
 		if (nb==corner_points.end()) nb=corner_points.begin();
 		// add owning cells to a list
 		list<Cell *> owning_cells;
 		Node &n(*(*i));
 		for (list<Neighbor>::const_iterator j=n.owners.begin();
 			 j!=n.owners.end();
 			 j++) {
 			owning_cells.push_back(j->cell);
+		}
 		Node &n2(*(*nb));
 		for (list<Neighbor>::const_iterator j=n2.owners.begin();
 			 j!=n2.owners.end();
 			 j++) {
 			owning_cells.push_back(j->cell);
+		}
 		// sort cell owners
 		owning_cells.sort( mem_fun( &Cell::Cmp ));
 		// find duplicates
 		vector<Cell *> duplicates;
 		list<Cell *>::const_iterator prevj = (--owning_cells.end());
 		for (list<Cell *>::const_iterator j=owning_cells.begin();
 			 j!=owning_cells.end();
 			 ( j++, prevj++) ) {
 			if (prevj==owning_cells.end()) prevj=owning_cells.begin();
 			if (*j==*prevj) duplicates.push_back(*j);
+		}
 		if (duplicates.size()==3) { // ignore cell boundary (this occurs only after the first division, I think)
 			vector<Cell *>::iterator dup_it = find_if(duplicates.begin(),duplicates.end(),mem_fun(&Cell::BoundaryPolP) );
 			if (dup_it!=duplicates.end())
 				duplicates.erase(dup_it);
 			else {
 				return;
+			}
+		}
 		// One Wall for each neighbor, so we should be able to correctly construct neighbor lists here.
 		if (duplicates[0]==this) {
 			//walls. new Wall(*nb,*i,duplicates[0],duplicates[1]) );
 			AddWall(  new Wall(*nb,*i,duplicates[0],duplicates[1]) );
 			if (!duplicates[1]->BoundaryPolP()) {
 				neighbors.push_back(duplicates[1]);
+			}
 		} else {
 			//walls.push_back( new Wall(*nb,*i,duplicates[1],duplicates[0]) );
 			AddWall ( new Wall(*nb,*i,duplicates[1],duplicates[0]) );
 			if (!duplicates[0]->BoundaryPolP()) {
 				neighbors.push_back(duplicates[0]);
+			}
+		}
+	}
+}
 void BoundaryPolygon::Draw(QGraphicsScene *c, QString tooltip) {
 	// Draw the BoundaryPolygon on a QCanvas object
 	CellItem* p = new CellItem(this, c);
 	QPolygonF pa(nodes.size());
 	int cc=0;
 	for (list<Node *>::const_iterator n=nodes.begin();
 		 n!=nodes.end();
 		 n++) {
 		Node *i=*n;
 		pa[cc++] = QPoint((int)((Offset().x+i->x)*Factor()),
 						  (int)((Offset().y+i->y)*Factor()) );
+	}
 	p->setPolygon(pa);
 	p->setPen(par.outlinewidth>=0?QPen( QColor(par.cell_outline_color),par.outlinewidth):QPen(Qt::NoPen));
 	p->setBrush( Qt::NoBrush );
 	p->setZValue(1);
 	if (!tooltip.isEmpty())
 		p->setToolTip(tooltip);
 	p->show();
+}
 void Cell::Flux(double *flux, double *D)  {
 	// loop over cell edges
 	for (int c=0;c<NChem();c++) flux[c]=0.;
 	for (list<Wall *>::iterator i=walls.begin();
 		 i!=walls.end();
 		 i++) {
 		// leaf cannot take up chemicals from environment ("no flux boundary")
 		if ((*i)->c2->BoundaryPolP()) continue;
 		// flux depends on edge length and concentration difference
 		for (int c=0;c<NChem();c++) {
 			double phi = (*i)->length * ( D[c] ) * ( ((Cell *)(*i)->c2)->chem[c] - chem[c] );
 			if ((*i)->c1!=this) {
 				cerr << "Warning, bad cells boundary: " << (*i)->c1->Index() << ", " << index << endl;
+			}
 			flux[c] += phi;
+		}
+	}
+}
 // graphics stuff, not compiled for batch versions
 #ifdef QTGRAPHICS
 #include "canvas.h"
 void Cell::Draw(QGraphicsScene *c, QString tooltip) {
 	// Draw the cell on a QCanvas object
 	if (DeadP()) {
 		cerr << "Cell " << index << " not drawn, because dead.\n";
 		return;
+	}
 	CellItem* p = new CellItem(this, c);
 	QPolygonF pa(nodes.size());
 	int cc=0;
 	for (list<Node *>::const_iterator n=nodes.begin();
 		 n!=nodes.end();
 		 n++) {
 		Node *i=*n;
 		pa[cc++] = QPoint((int)((offset[0]+i->x)*factor),
 						  (int)((offset[1]+i->y)*factor) );
+	}
 	QColor cell_color;
-	m->plugin->SetCellColor(*this,cell_color);
+	m->plugin->SetCellColor(this,&cell_color);
 	p->setPolygon(pa);
 	p->setPen(par.outlinewidth>=0?QPen( QColor(par.cell_outline_color),par.outlinewidth):QPen(Qt::NoPen));
 	p->setBrush( cell_color );
 	p->setZValue(1);
 	if (!tooltip.isEmpty())
 		p->setToolTip(tooltip);
 	p->show();
+}
 void Cell::DrawCenter(QGraphicsScene *c) const {
   // Maginfication derived similarly to that in nodeitem.cpp
   // Why not use Cell::Magnification()?
   const double mag = par.node_mag;
 	// construct an ellipse
   QGraphicsEllipseItem *disk = new QGraphicsEllipseItem ( -1*mag, -1*mag, 2*mag, 2*mag, 0, c );
 	disk->setBrush( QColor("forest green") );
 	disk->setZValue(5);
 	disk->show();
 	Vector centroid=Centroid();
 	disk -> setPos((offset[0]+centroid.x)*factor,(offset[1]+centroid.y)*factor);
+}
 void Cell::DrawNodes(QGraphicsScene *c) const {
 	for (list<Node *>::const_iterator n=nodes.begin();
 		 n!=nodes.end();
 		 n++) {
 		Node *i=*n;
 		//QCanvasEllipse *item = new QCanvasEllipse( 10, 10, c);
 		NodeItem *item = new NodeItem ( &(*i), c );
 		//QGraphicsRectItem *item = new QGraphicsRectItem(-50, -50, 50, 50, 0, c);
 		//disk->setBrush( QColor("IndianRed") );
 		/*if (i->sam) {
 		 item->setBrush( purple );
 		 } else {
 		 if (i->boundary) {
 		 item->setBrush( deep_sky_blue );
+		 }
 		 else {
 		 item->setBrush( indian_red );
+		 }
 		 }*/
 		item->setColor();
 		/*(if (item->getNode().DeadP()) {
 		 item->setBrush( QBrush (Qt::Dense6Pattern) );
 		 }*/
 		item->setZValue(5);
 		item->show();
 		item ->setPos(((offset[0]+i->x)*factor),
 					  ((offset[1]+i->y)*factor) );
+	}
+}
 void Cell::DrawIndex(QGraphicsScene *c) const {
 	//  stringstream text;
 	//     text << index;
 	//     Vector centroid = Centroid();
 	//     QCanvasText *number = new QCanvasText ( QString (text.str()), c );
 	//     number->setColor( QColor(par.textcolor) );
 	//     number->setZ(20);
 	//     number->setFont( QFont( "Helvetica", par.cellnumsize, QFont::Bold) );
 	//     number->show();
 	//     number -> move((int)((offset[0]+centroid.x)*factor),
 	// 		   (int)((offset[1]+centroid.y)*factor) );
 	DrawText( c, QString("%1").arg(index));
+}
 // Draw any text in the cell's center
 void Cell::DrawText(QGraphicsScene *c, const QString &text) const {
 	Vector centroid = Centroid();
 	QGraphicsSimpleTextItem *ctext = new QGraphicsSimpleTextItem ( text, 0, c );
 	ctext->setPen( QPen(QColor(par.textcolor)) );
 	ctext->setZValue(20);
 	ctext->setFont( QFont( "Helvetica", par.cellnumsize, QFont::Bold) );
 	//ctext->setTextFlags(Qt::AlignCenter);
 	ctext->show();
 	ctext ->setPos(((offset[0]+centroid.x)*factor),
 				   ((offset[1]+centroid.y)*factor) );
+}
 void Cell::DrawAxis(QGraphicsScene *c) const {
 	Vector long_axis;
 	double width;
 	Length(&long_axis, &width);
 	//cerr << "Length is "  << length << endl;
 	long_axis.Normalise();
 	Vector short_axis=long_axis.Perp2D();
 	Vector centroid = Centroid();
 	Vector from = centroid - 0.5 * width * short_axis;
 	Vector to = centroid + 0.5 * width *short_axis;
 	QGraphicsLineItem *line = new QGraphicsLineItem(0, c);
 	line->setPen( QPen(QColor(par.arrowcolor),2) );
 	line->setZValue(2);
 	line->setLine( ( (offset[0]+from.x)*factor ),
 				  ( (offset[1]+from.y)*factor ),
 				  ( (offset[0]+to.x)*factor ),
 				  ( (offset[1]+to.y)*factor ) );
 	line->setZValue(10);
 	line->show();
+}
 void Cell::DrawStrain(QGraphicsScene *c) const {
 	MyWarning::warning("Sorry, Cell::DrawStrain temporarily not implemented.");
 	/* Vector long_axis;
 	double width;
 	Length(&long_axis, &width);
 	//cerr << "Length is "  << length << endl;
 	long_axis.Normalise();
 	Vector short_axis=long_axis.Perp2D();
 	//  To test method "Strain" temporarily substitute "short_axis" for "strain"
 	Vector strain = Strain();
 	//strain.Normalise();
 	//static ofstream strainf("strain.dat");
 	//strainf << strain.Norm() << endl;
 	Vector centroid = Centroid();
 	// Vector from = centroid - 0.5 * width * short_axis;
     // Vector to = centroid + 0.5 * width *short_axis;
 	Vector from = centroid - 0.5 * strain;
 	Vector to = centroid + 0.5 * strain;
 	QGraphicsArrowItem *arrow = new QGraphicsArrowItem(0, c);
 	arrow->setPen( QPen(QColor(par.arrowcolor),100) );
 	arrow->setLine( ( (offset[0]+from.x)*factor ),
 				   ( (offset[1]+from.y)*factor ),
 				   ( (offset[0]+to.x)*factor ),
 				   ( (offset[1]+to.y)*factor ) );
 	arrow->setZValue(10.);
 	arrow->show();
 	*/
+}
 // Draw connecting lines to neighbors
 /*void Cell::DrawTriangles(QCanvas &c) {
  for (list<Neighbor>::const_iterator nb=nb_list.begin();
  nb!=nb_list.end();
  nb++) {
  QCanvasLine *line = new QCanvasLine(&c);
  line->setPen( QPen(QColor("black"),2) );
  line->setZ(2);
  line->setPoints((offset[0]+x)*factor,(offset[1]+y)*factor,
  (offset[0]+nb->c->x)*factor,(offset[1]+nb->c->y)*factor);
  line->setZ(10);
  line->show();
+ }
  }*/
 void Cell::DrawFluxes(QGraphicsScene *c, double arrowsize)  {
 	// get the mean flux through this cell
 	//Vector vec_flux = ReduceWalls( mem_fun_ref( &Wall::VizFlux ), Vector() );
 	Vector vec_flux = ReduceCellAndWalls<Vector>( PINdir );
 	vec_flux.Normalise();
 	vec_flux *= arrowsize;
 	QGraphicsArrowItem *arrow = new QGraphicsArrowItem(0,c);
 	Vector centroid = Centroid();
 	Vector from = centroid - vec_flux/2.;
 	Vector to = centroid + vec_flux/2.;
 	arrow->setPen( QPen(QColor(par.arrowcolor),par.outlinewidth));
 	arrow->setZValue(2);
 	arrow->setLine( ( (offset[0]+from.x)*factor ),
 				   ( (offset[1]+from.y)*factor ),
 				   ( (offset[0]+to.x)*factor ),
 				   ( (offset[1]+to.y)*factor ) );
 	arrow->setZValue(10);
 	arrow->show();
+}
 void Cell::DrawWalls(QGraphicsScene *c) const {
 	for_each(walls.begin(), walls.end(), bind2nd ( mem_fun ( &Wall::Draw ) , c ) );
 	// to see the cells connected the each wall (for debugging), uncomment the following
 	//for_each(walls.begin(), walls.end(), bind2nd ( mem_fun ( &Wall::ShowStructure ), c ) );
+}
 void Cell::DrawValence(QGraphicsScene *c) const {
 	DrawText(c, QString("%1").arg(walls.size()) );
+}
 #endif
 /*! \brief Recalculate the lengths of the cell's Walls.
  Call this function after the Monte Carlo updates, and before doing the reaction-diffusion iterations.
  */
 void Cell::SetWallLengths(void) {
 	for (list<Wall *>::iterator de=walls.begin();
 		 de!=walls.end();
 		 de++) {
 		// Step 1: find the path of nodes leading along the Wall.
 		// A Wall often represents a curved cell wall: we want the total
 		// length _along_ the wall here...
 		// Locate first and second nodes of the edge in list of nodes
 		list<Node *>::const_iterator first_node_edge = find(nodes.begin(), nodes.end(), (*de)->n1);
 		list<Node *>::const_iterator second_node_edge_plus_1 = ++find(nodes.begin(), nodes.end(), (*de)->n2);
 		double sum_length = 0.;
 		// Now, walk to the second node of the edge in the list of nodes
 		for (list<Node *>::const_iterator n=++first_node_edge;
 			 n!=second_node_edge_plus_1;
 			 ++n ) {
 			if (n==nodes.end()) n=nodes.begin(); /* wrap around */
 			list<Node *>::const_iterator prev_n = n;
 			if (prev_n==nodes.begin()) prev_n=nodes.end();
 			--prev_n;
 			// Note that Node derives from a Vector, so we can do vector calculus as defined in vector.h
 			sum_length += (*(*prev_n) - *(*n)).Norm();
 			//cerr << "Node " << *prev_n << " to " << *n << ", cumulative length = " << sum_length << endl;
+		}
 		// We got the total length of the Wall now, store it:
 		(*de)->length = sum_length;
 		//cerr << endl;
 		// goto next de
+	}
+}
 //! Add Wall w to the list of Walls
 void Cell::AddWall( Wall *w ) {
 	// if necessary, we could try later inserting it at the correct position
 	if (w->c1 == w->c2 ){
 		cerr << "Wall between identical cells: " << w->c1->Index()<< endl;
+	}
 	// Add Wall to Cell's list
 	walls.push_back( w );
 	// Add wall to Mesh's list if it isn't there yet
 	if (find (
 			  m->walls.begin(), m->walls.end(),
 			  w )
 		== m->walls.end() ) {
 		m->walls.push_back(w);
+	}
+}
 //! Remove Wall w from the list of Walls
 list<Wall *>::iterator Cell::RemoveWall( Wall *w ) {
 	// remove wall from Mesh's list
 	m->walls.erase(
 				   find(
 						m->walls.begin(), m->walls.end(),
 						w )
 				   );
 	// remove wall from Cell's list
 	return
 	walls.erase (
 				 find(
 					  walls.begin(), walls.end(),
 					  w )
 				 );
+}
 void Cell::EmitValues(double t) {
 	//  cerr << "Attempting to emit " << t << ", " << chem[0] << ", " << chem[1] << endl;
 	//chem[3] = SumTransporters( 1 );
 	emit ChemMonValue(t, chem);
+}

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
  *  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.
+ *
  */
 // 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
 // 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.;
 		cerr << "Constructor of CellsStaticDatamembers\n";
+	}
 	~CellsStaticDatamembers() {
 		cerr << "Oops! Desctructor of CellsStaticDatamembers called\n";
+	}
 	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(const Vector &src); // not allowed (we cannot know to which mesh
 	/// the CellBase will belong...)
     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;
+	}
     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) {
 	//area=0.;
 	//length=0.;
+      }
       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;
+	}
 	//Vector Strain(void) const;
     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 XFigPrint(std::ostream &os) const;
     void Dump(ostream &os) const;
 	QString printednodelist(void);
    // void OnDivide(ParentInfo &parent_info, CellBase &daughter);
     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 );
 	sum += ((*w)->c1 == this) ?
 	  f( ((*w)->c1), ((*w)->c2), *w ) :
 	  f( ((*w)->c2), ((*w)->c1), *w );
+      }
       return sum;
+    }
 	/* template<class Op> void LoopWalls(Op f) {
 		for (list<Wall *>::const_iterator w=walls.begin();
 			 w!=walls.end();
 			 w++) {
 			( **w)->f;
+		}
 	}*/
     //! 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;
     //double length;
     //Vector meanflux;
     //int valence;
     // 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
     inline static void ClearNCells(void) {
       NCells()=0;
+    }
     bool marked;
     int div_counter;
 };
 ostream &operator<<(ostream &os, const CellBase &v);
 inline Vector PINdir(CellBase &here, CellBase &nb, Wall &w) {
 	return w.getTransporter( &here, 1)  *  w.getInfluxVector(&here);
 inline Vector PINdir(CellBase *here, CellBase *nb, Wall *w) {
 	return w->getTransporter( here, 1)  *  w->getInfluxVector(here);
+}
 #endif

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
 QMAKE_CXXFLAGS_DEBUG += -g3
 QMAKE_CXXFLAGS_DEBUG += -DQDEBUG
 QMAKE_CXXFLAGS_DEBUG -= -finstrument-functions
 DEFINES = QTGRAPHICS # VLEAFPLUGIN
-DESTDIR = build_models/lib
+DESTDIR = ../lib
 PERLDIR = ./perl
 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 {
  system(if `which perl > /dev/null 2>&1` ; then rm -f parameter.cpp parameter.h pardialog.cpp pardialog.h; fi)
  system(if `which perl > /dev/null 2>&1` ; then perl $$PERLDIR/make_parameter_source.pl $$PARTMPL; fi)
  system(if `which perl > /dev/null 2>&1` ; then perl $$PERLDIR/make_pardialog_source.pl $$PARTMPL; fi)
 #system(if `which perl > /dev/null 2>&1` ; then perl $$PERLDIR/make_xmlwritecode.pl -h $$REACTIONS; fi)
  QMAKE_CXXFLAGS += -fPIC -I/usr/include/libxml2
  QMAKE_LFLAGS += -fPIC
  LIBS += -lxml2 -lz -lm
+}
 win32 {
  system(WHERE /Q perl && IF errorlevel 0 (DEL parameter.cpp parameter.h pardialog.cpp pardialog.h)
  system(WHERE /Q perl && IF errorlevel 0 (perl $$PERLDIR\make_parameter_source.pl $$PARTMPL)
  system(WHERE /Q perl && IF errorlevel 0 (perl $$PERLDIR\make_pardialog_source.pl $$PARTMPL)
 #system(WHERE /Q perl && IF errorlevel 0 (perl $$PERLDIR\make_xmlwritecode.pl -h $$REACTIONS)
  LIBXML2DIR = C:\libxml2
  LIBICONVDIR = C:\libiconv
  LIBZDIR = C:\libz
  QMAKE_CXXFLAGS += -DLIBXML_STATIC
  QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include
+}
+#

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
  *  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.
+ *
  */
 // 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>
 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>( P *obj) { return *obj; }
 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);
 		//boundary_polygon = new BoundaryPolygon();
 		time = 0.;
 		plugin = 0;
 	};
 	~Mesh(void) {
 		delete boundary_polygon;
 		/* if (plugin)
 			delete plugin;*/
 	};
 	void Clean(void);
 	//void Plane(int xwidth, int ywidth, int nx, int ny, bool randomP=false);
 	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);
 	/*  void GMVoutput(ostream &os,
 	 const char *codename=0, const char *codever=0,
 	 const char *comments=0);*/
 	//void RandPoints(int npoints);
 	inline Cell &getCell(int i) {
 		if ((unsigned)i<cells.size())
 			return *cells[i];
 		else {
 			cerr << i << endl;
 			cerr << "size is " << cells.size() << endl;
 			abort();
 			//	throw("Index out of range in Mesh::getCell");
+		}
+	}
 	inline Node &getNode(int i) {
 		//if (i >= nodes.size() || i < 0) {
 		//  cerr << "Mesh::getNode: Warning. Index " << i << " out of range.\n";
 		// }
 		return *nodes[i];
+	}
 	//double Diffusion(void);
 	inline int size(void) {
 		return cells.size();
+	}
 	inline int nnodes(void) {
 		return nodes.size();
+	}
 	//void SortNBLists(void);
 	/*template<class Op> void LoopCells(Op f) {
 	 for (vector<Cell>::iterator i=cells.begin();
 	 i!=cells.end();
 	 i++) {
 	 f(*i);
+	 }
 	 }*/
 	/*! \brief Calls function f for all Cells f.
 	 Using this template requires some fiddling with function adaptors bind2nd and mem_fun_ref.
 	 Example usage for calling a member function on each cell:
 	 mesh.LoopCells( bind2nd (mem_fun_ref( &Cell::DrawDiffEdges), &canvas ) );
 	 This calls Cell's member function DrawDiffEdges, taking one
 	 argument canvas, on all Cell objects in the current Mesh.
 	 */
 	template<class Op> void LoopCells(Op f) {
 		for (vector <Cell *>::iterator i=cells.begin();
 			 i!=cells.end();
 			 i++) {
 			f(**i);
+		}
 		//for_each(cells.begin(),cells.end(),f);
+	}
 	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);
+		}
 		//for_each(cells.begin(),cells.end(),f);
+	}
 	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);
 			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;
+			}
+		}
+	}
 /*	template<class Op1, class Cont> void ExtractFromCells(Op1 f, Cont res) {
 		for (vector<Cell>::iterator i=cells.begin();
 			 i!=cells.end();
 			 i++) {
 			*(res++) = ( f(*i) );
+		}
 	}*/
 	// 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();
+		}
 		//copy (node_insertion_queue.begin(),node_insertion_queue.end(),ostream_iterator<Edge>(cerr, " "));
+	}
 	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();
 	//  template<class ReactFunction> ReactDiffuse(const double D, ReactFunction& react) {
 	void ReactDiffuse( double delta_t = 1 );
 	//void Diffuse(const double D);
 	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, 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) {
 		/* if (plugin)
 			delete 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;
 	unique_queue<Edge> node_insertion_queue;
 	BoundaryPolygon *boundary_polygon;
 	double time;
 	SimPluginInterface *plugin;
 	// Private member functions
 	void AddNodeToCell(Cell *c, Node *n, Node *nb1 , Node *nb2);
 	void AddNodeToCellAtIndex(Cell *c, Node *n, Node *nb1 , Node *nb2, list<Node *>::iterator ins_pos);
 	void InsertNode(Edge &e);
 	inline Node *AddNode(Node *n) {
 		nodes.push_back(n);
 		shuffled_nodes.push_back(n);
 		n->m=this;
 		return n;
+	}
 	inline Cell *AddCell(Cell *c) {
 		cells.push_back(c);
 		shuffled_cells.push_back(c);
 		//cerr << "Shuffled cell indices:  ";
 		/*copy(shuffled_cells.begin(),shuffled_cells.end(),ostream_iterator<int>(cerr," "));
 		 cerr << endl;*/
 		c->m=this;
 		return c;
+	}
 	//int Delaunay(void);
 	void CircumCircle(double x1,double y1,double x2,double y2,double x3,double y3,
 					  double *xc,double *yc,double *r);
 	// void RenumberCells(void);
 };
 #endif

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
  *  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.
+ *
  */
 #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 {
 			MyWarning::warning("Could not load plugin %s",fileName.toStdString().c_str());
 			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!");
+  }
   //QVector<SimPluginInterface *> plugins;
   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);
+  }
   //	mesh->StandardInit();
+}

src/simplugin.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  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.
+ *
  */
 #ifndef _SIMPLUGIN_H_
 #define _SIMPLUGIN_H_
 #include <QtPlugin>
 #include <QMetaType>
 #include "cellbase.h"
 #include "wallbase.h"
 class Parameter;
 #include <QColor>
 #include <QString>
 class SimPluginInterface {
 public:
 	virtual QString ModelID(void) = 0;
 	virtual ~SimPluginInterface() { }
 	// Executed after the cellular mechanics steps have equillibrized
-	virtual void CellHouseKeeping(CellBase &c) = 0;
+	virtual void CellHouseKeeping(CellBase *c) = 0;
 	// Differential equations describing transport of chemicals from cell to cell
 	virtual void CelltoCellTransport(Wall *, double *dchem_c1, double *dchem_c2) = 0;
 	// Differential equations describing chemical reactions taking place at or near the cell walls
 	// (e.g. PIN accumulation)
 	virtual void WallDynamics(Wall *w, double *dw1, double *dw)  = 0;
 	// Differential equations describing chemical reactions inside the cells
 	virtual void CellDynamics(CellBase *c, double *dchem) = 0;
 	// to be executed after a cell division
-	virtual void OnDivide(ParentInfo &parent_info, CellBase &daughter1, CellBase &daughter2) = 0;
+	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) = 0;
 	// to be executed for coloring a cell
-	virtual void SetCellColor(CellBase &c, QColor &color) = 0;
+	virtual void SetCellColor(CellBase *c, QColor *color) = 0;
 	// Number of chemicals
 	virtual int NChem(void) = 0;
 	// For internal use; not to be redefined by end users
 	virtual void SetParameters(Parameter *pass_pars);// { par = pass_pars; }
 	virtual void SetCellsStaticDatamembers (CellsStaticDatamembers *cells_static_data_members_of_main);
 protected:
 	class Parameter *par;
 };
 Q_DECLARE_INTERFACE(SimPluginInterface,
-                    "nl.cwi.VirtualLeaf.SimPluginInterface/1.1")
+                    "nl.cwi.VirtualLeaf.SimPluginInterface/1.2")
 Q_DECLARE_METATYPE(SimPluginInterface *)
 #endif
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)