EI/VirtualLeaf Changeset - 782330072e62 · Centrum Wiskunde & Informatica (CWI)

Changeset - 782330072e62

Parent rev.

Child rev.

[Not reviewed]

default

! ! !

Michael Guravage - 15 years ago 2010-06-17 18:13:46
michael.guravage@cwi.nl

Reformatted the source files and generally straighten up the code.

--
user: Michael Guravage <michael.guravage@cwi.nl>
branch 'default'

changed src/Neighbor.cpp
changed src/Neighbor.h
changed src/OptionFileDialog.cpp
changed src/OptionFileDialog.h
changed src/UniqueMessage.cpp
changed src/UniqueMessage.h
changed src/VirtualLeaf.cpp
changed src/apoplastitem.cpp
changed src/apoplastitem.h
changed src/build_models/auxingrowthplugin.cpp
changed src/build_models/auxingrowthplugin.h
changed src/build_models/meinhardtplugin.cpp
changed src/build_models/meinhardtplugin.h
changed src/build_models/testplugin.cpp
changed src/build_models/testplugin.h
changed src/build_models/translate_plugin.pl
changed src/canvas.cpp
changed src/canvas.h
changed src/cell.cpp
changed src/cell.h
changed src/cellbase.cpp
changed src/cellbase.h
changed src/cellitem.cpp
changed src/cellitem.h
changed src/curvecolors.h
changed src/data_plot.cpp
changed src/data_plot.h
changed src/far_mem_5.h
changed src/flux_function.h
changed src/forwardeuler.cpp
changed src/forwardeuler.h
changed src/infobar.h
changed src/mainbase.cpp
changed src/mainbase.h
changed src/matrix.cpp
changed src/matrix.h
changed src/maxmin.h
changed src/mesh.cpp
changed src/mesh.h
changed src/miscq.cpp
changed src/miscq.h
changed src/modelcatalogue.cpp
changed src/modelcatalogue.h
changed src/modelelement.h
changed src/node.cpp
changed src/node.h
changed src/nodeitem.cpp
changed src/nodeitem.h
changed src/nodeset.cpp
changed src/nodeset.h
changed src/output.cpp
changed src/output.h
changed src/parameter.cpp
changed src/parameter.h
changed src/pardialog.cpp
changed src/pardialog.h
changed src/parse.cpp
changed src/parse.h
changed src/perl/deployapp.pl
changed src/perl/histogram.pl
changed src/perl/make_parameter_source.pl
changed src/perl/make_pardialog_source.pl
changed src/perl/make_xmlwritecode.pl
changed src/pi.h
changed src/qcanvasarrow.h
changed src/random.cpp
changed src/random.h
changed src/rseed.cpp
changed src/rungekutta.cpp
changed src/rungekutta.h
changed src/simitembase.cpp
changed src/simitembase.h
changed src/simplugin.cpp
changed src/simplugin.h
changed src/sqr.h
changed src/tiny.h
changed src/transporterdialog.cpp
changed src/transporterdialog.h
changed src/vector.cpp
changed src/vector.h
changed src/vleafmodel.h
changed src/wall.cpp
changed src/wall.h
changed src/wallbase.cpp
changed src/wallbase.h
changed src/wallitem.cpp
changed src/wallitem.h
changed src/warning.cpp
changed src/warning.h
changed src/xmlwrite.cpp
changed src/xmlwrite.h

22 files changed:

src/Neighbor.cpp

src/Neighbor.h

src/OptionFileDialog.cpp

src/OptionFileDialog.h

src/UniqueMessage.cpp

src/UniqueMessage.h

src/VirtualLeaf.cpp

src/apoplastitem.cpp

src/apoplastitem.h

src/build_models/auxingrowthplugin.cpp

167

170

src/build_models/auxingrowthplugin.h

src/build_models/meinhardtplugin.cpp

src/build_models/meinhardtplugin.h

src/build_models/testplugin.cpp

src/build_models/testplugin.h

src/build_models/translate_plugin.pl

src/canvas.cpp

490

475

src/canvas.h

src/cell.cpp

1580

1636

src/cell.h

133

141

src/cellbase.cpp

530

538

src/cellbase.h

362

383

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

0 comments (0 inline, 0 general)

src/Neighbor.cpp

➞

Show inline comments

@@ @@ -26,21 +26,22 @@ @@
 static const std::string _module_id("$Id$");
 Neighbor::Neighbor(void):
   cell(NULL), nb1(NULL), nb2(NULL){}
 Neighbor::Neighbor(Cell *c, Node *n1, Node *n2):
  cell(c), nb1(n1), nb2(n2){}
+  cell(c), nb1(n1), nb2(n2){}
 Neighbor::Neighbor(const Neighbor &src):
   cell(src.cell), nb1(src.nb1), nb2(src.nb2){} // copy constructor
 bool Neighbor::CellEquals(int i) const { return cell->Index() == i; }
 bool Neighbor::Cmp(Neighbor &c) const { return cell->Index() < c.cell->Index(); } // Compare cell indices not pointers.
 bool Neighbor::Eq(Neighbor &c) const { return cell->Index() == c.cell->Index(); }
 Cell* Neighbor::getCell(void) const { return cell; }
 bool neighbor_cell_eq(const Neighbor &n1, const Neighbor &n2) {
   return (n1.getCell())->Index() == (n2.getCell())->Index(); // Compare cell indices not pointers.
+}
 // finis
 /* finis */

src/Neighbor.h

➞

Show inline comments

@@ @@ -47,13 +47,13 @@ class Neighbor { @@
   Node *nb1, *nb2;
  public:
   Neighbor(void);
   Neighbor(Cell*, Node*, Node*);
   Neighbor(const Neighbor&);
   bool CellEquals(int) const;
   bool Cmp(Neighbor&) const;
   bool Eq(Neighbor&) const;
   Cell* getCell(void) const;
   void XMLAdd(xmlNodePtr) const;
@@ @@ -65,7 +65,8 @@ ostream &operator<<(ostream &os, const N @@
 // Realize that we're equating like pointers with object equivalence!
 bool neighbor_cell_eq(const Neighbor &n1, const Neighbor &n2);
 #endif
 // finis
 /* finis */

src/OptionFileDialog.cpp

➞

Show inline comments

@@ @@ -24,26 +24,27 @@ @@
 #include <QCheckBox>
 #include <iostream>
 using namespace  std;
 static const std::string _module_id("$Id$");
 OptionFileDialog::OptionFileDialog(QWidget *parent, const char *name, bool modal) : Q3FileDialog(parent, name, modal) {
 OptionFileDialog::OptionFileDialog(QWidget *parent, const char *name, bool modal) : Q3FileDialog(parent, name, modal)
+{
   //cerr << "This is an OptionFileDialog\n";
   geometrycheck = new QCheckBox("geometry",this);
   geometrycheck -> setCheckState(Qt::Checked);
 	//cerr << "This is an OptionFileDialog\n";
 	geometrycheck = new QCheckBox("geometry",this);
 	geometrycheck -> setCheckState(Qt::Checked);
 	parcheck = new QCheckBox("parameters", this);
 	parcheck -> setCheckState(Qt::Checked);
 	addToolButton(geometrycheck);
 	addToolButton(parcheck);
   parcheck = new QCheckBox("parameters", this);
   parcheck -> setCheckState(Qt::Checked);
   addToolButton(geometrycheck);
   addToolButton(parcheck);
 };
 OptionFileDialog::OptionFileDialog ( const QString & dirName, const QString & filter , QWidget * parent, const char * name , bool modal  ) :
 		Q3FileDialog(dirName, filter, parent, name, modal) {
 			cerr << "This is an OptionFileDialog\n";
 	};
 OptionFileDialog::OptionFileDialog ( const QString & dirName, const QString & filter ,
 				     QWidget * parent, const char * name , bool modal  ) :
   Q3FileDialog(dirName, filter, parent, name, modal) {
   cerr << "This is an OptionFileDialog\n";
 };
 /* finis */

src/OptionFileDialog.h

➞

Show inline comments

@@ @@ -24,20 +24,23 @@ @@
 #define _OPTIONFILEDIALOG_H_
 #include <Q3FileDialog>
 #include <QCheckBox>
 class OptionFileDialog : public Q3FileDialog {
 	Q_OBJECT
 public:
 	OptionFileDialog(QWidget *parent = 0, const char *name = 0, bool modal = false);
 	OptionFileDialog ( const QString & dirName, const QString & filter = QString(), QWidget * parent = 0, const char * name = 0, bool modal = false );
 	bool readGeometryP(void) const { return geometrycheck->checkState()==Qt::Checked; }
 	bool readParametersP(void) const { return parcheck->checkState()==Qt::Checked; }
   Q_OBJECT
  public:
   OptionFileDialog(QWidget *parent = 0, const char *name = 0, bool modal = false);
   OptionFileDialog ( const QString & dirName, const QString & filter = QString(),
 		     QWidget * parent = 0, const char * name = 0, bool modal = false );
 private:
 	QCheckBox *geometrycheck;
 	QCheckBox *parcheck;
   bool readGeometryP(void) const { return geometrycheck->checkState()==Qt::Checked; }
   bool readParametersP(void) const { return parcheck->checkState()==Qt::Checked; }
  private:
   QCheckBox *geometrycheck;
   QCheckBox *parcheck;
 };
 #endif
 /* finis */

src/UniqueMessage.cpp

➞

Show inline comments

@@ @@ -29,57 +29,56 @@ @@
 #include <iostream>
 static const std::string _module_id("$Id$");
 using namespace std;
 UniqueMessageBox::UniqueMessageBox ( /* Icon icon,*/
 									 const QString & title,
 									 const QString & text,
 									 QWidget * parent ,
 									 Qt::WindowFlags f ) :
 QDialog(parent, f) {
 	label = new QLabel(text);
 	boxtext = text;
 	show_again = new QCheckBox(tr("Do not show this message again"));
 	okButton = new QPushButton(tr("Ok"));
 	if (issued_messages.contains(boxtext) ) {
 		cerr << "Saw message before\n";
 		display = false;
 	} else {
 		display=true;
+	}
 	connect(okButton, SIGNAL(clicked()), this, SLOT(close()) );
 	QHBoxLayout *hlayout = new QHBoxLayout;
 	hlayout->addWidget(label);
 	hlayout->addWidget(okButton);
 	QVBoxLayout *layout = new QVBoxLayout;
 	layout->addLayout(hlayout);
 	layout->addWidget(show_again);
 	setLayout(layout);
 	setWindowTitle(title);
 				    const QString & title,
 				    const QString & text,
 				    QWidget * parent ,
 				    Qt::WindowFlags f ) :
   QDialog(parent, f) {
   label = new QLabel(text);
   boxtext = text;
   show_again = new QCheckBox(tr("Do not show this message again"));
   okButton = new QPushButton(tr("Ok"));
   if (issued_messages.contains(boxtext) ) {
     cerr << "Saw message before\n";
     display = false;
   } else {
     display=true;
+  }
   connect(okButton, SIGNAL(clicked()), this, SLOT(close()) );
   QHBoxLayout *hlayout = new QHBoxLayout;
   hlayout->addWidget(label);
   hlayout->addWidget(okButton);
   QVBoxLayout *layout = new QVBoxLayout;
   layout->addLayout(hlayout);
   layout->addWidget(show_again);
   setLayout(layout);
   setWindowTitle(title);
 };
 UniqueMessageBox::~UniqueMessageBox(void)  {
 	if (show_again->checkState() == Qt::Checked ) {
 		cerr << "Message won't be shown again\n";
 		issued_messages << boxtext;
+	}
   if (show_again->checkState() == Qt::Checked ) {
     cerr << "Message won't be shown again\n";
     issued_messages << boxtext;
+  }
+}
 int UniqueMessageBox::exec(void)  {
 	if (display)
 		return QDialog::exec();
 	else {
 		return 1;
+	}
   if (display)
     return QDialog::exec();
   else {
     return 1;
+  }
+}
 QStringList UniqueMessageBox::issued_messages;
 /* finis */

src/UniqueMessage.h

➞

Show inline comments

@@ @@ -28,27 +28,29 @@ @@
 #include <QDialog>
 #include <QCheckBox>
 #include <QStringList>
 #include <QLabel>
 class UniqueMessageBox : public QDialog {
 	Q_OBJECT
 public:
 	UniqueMessageBox ( /* Icon icon,*/
 			  const QString & title,
 			  const QString & text,
 			  /* StandardButtons buttons = Ok, */
 			  QWidget * parent = 0 , Qt::WindowFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint );
 	~UniqueMessageBox();
 	int exec(void);
 private:
 	static QStringList issued_messages;
 	bool display;
 	QCheckBox *show_again;
 	QPushButton *okButton;
 	QLabel *label;
 	QString boxtext;
   Q_OBJECT
  public:
   UniqueMessageBox ( /* Icon icon,*/
 		    const QString & title,
 		    const QString & text,
 		    /* StandardButtons buttons = Ok, */
 		    QWidget * parent = 0 , Qt::WindowFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint );
   ~UniqueMessageBox();
   int exec(void);
  private:
   static QStringList issued_messages;
   bool display;
   QCheckBox *show_again;
   QPushButton *okButton;
   QLabel *label;
   QString boxtext;
 };
 #endif
 /* finis */

src/VirtualLeaf.cpp

➞

Show inline comments

@@ @@ -74,16 +74,16 @@ public: @@
     cerr << n.Index() << ": " << n <<  endl;
+  }
 };
 class EdgeSource {
 public:
   void operator() (Cell &c) {
     if (c.AtBoundaryP()) {
       cerr << "Cell " << c.Index() << " is a source cell.\n";
       c.SetSource(0,par.source);
     } else {
       cerr << "Cell " << c.Index() << " is _not_ a source cell.\n";
+    }
@@ @@ -115,13 +115,13 @@ class DrawCell { @@
 public:
   void operator() (Cell &c,QGraphicsScene &canvas, MainBase &m) const {
     if (m.ShowBorderCellsP() || c.Boundary()==Cell::None) {
       if (!m.ShowBoundaryOnlyP() && !m.HideCellsP()) {
 	if (m.ShowToolTipsP()) {
 	  QString info_string=QString("Cell %1, chemicals: ( %2, %3, %4, %5, %6)\n %7 of PIN1 at walls.\n Area is %8\n PIN sum is %9\n Circumference is %10\n Boundary type is %11").arg(c.Index()).arg(c.Chemical(0)).arg(c.Chemical(1)).arg(c.Chemical(2)).arg(c.Chemical(3)).arg(c.Chemical(4)).arg(c.SumTransporters(1)).arg(c.Area()).arg(PINSum(c)).arg(c.Circumference()).arg(c.BoundaryStr());
 	  info_string += "\n" + c.printednodelist();
 	  c.Draw(&canvas, info_string);
 	} else {
 	  c.Draw(&canvas);
+	}
+      }
@@ @@ -135,162 +135,155 @@ public: @@
+  }
 };
 Mesh mesh;
 bool batch=false;
 void MainBase::Plot(int resize_stride) {
 void MainBase::Plot(int resize_stride)
+{
   clear();
   static int count=0;
   if (resize_stride) {
     if ( !((++count)%resize_stride) ) {
       FitLeafToCanvas();
+    }
+  }
   mesh.LoopCells(DrawCell(),canvas,*this);
   if (ShowNodeNumbersP())
     mesh.LoopNodes( bind2nd (mem_fun_ref ( &Node::DrawIndex), &canvas ) ) ;
   if (ShowCellNumbersP())
     mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawIndex), &canvas ) ) ;
   if (ShowCellAxesP())
     mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawAxis), &canvas ) );
   if (ShowCellStrainP())
     mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawStrain), &canvas ) );
   if (ShowWallsP())
     mesh.LoopWalls( bind2nd( mem_fun_ref( &Wall::Draw ), &canvas ) );
   if (ShowApoplastsP())
     mesh.LoopWalls( bind2nd( mem_fun_ref( &Wall::DrawApoplast ), &canvas ) );
   if (ShowMeshP())
     mesh.DrawNodes(&canvas);
   if (ShowBoundaryOnlyP())
     mesh.DrawBoundary(&canvas);
   if ( ( batch || MovieFramesP() )) {
     static int frame = 0;
     // frame numbers are sequential for the most frequently written file type.
     // for the less frequently written file type they match the other type
     if (!(count%par.storage_stride) )  {
       stringstream fname;
       fname << par.datadir << "/leaf.";
       fname.fill('0');
       fname.width(6);
       fname << frame << ".jpg";
       if (par.storage_stride <= par.xml_storage_stride) {
 	frame++;
+      }
       // Write high-res JPG snapshot every plot step
       Save(fname.str().c_str(), "JPEG",1024,768);
+    }
     if (!(count%par.xml_storage_stride)) {
       stringstream fname;
       fname << par.datadir << "/leaf.";
       fname.fill('0');
       fname.width(6);
       fname << frame << ".xml";
       if (par.xml_storage_stride < par.storage_stride) {
 	frame++;
+      }
       // Write XML file every ten plot steps
       mesh.XMLSave(fname.str().c_str(), XMLSettingsTree());
+    }
+  }
+}
 INIT {
   //mesh.SetSimPlugin(plugin);
   if (leaffile) {
     xmlNode *settings;
     mesh.XMLRead(leaffile, &settings);
     main_window->XMLReadSettings(settings);
     xmlFree(settings);
     main_window->UserMessage(QString("Ready. Time is %1").arg(mesh.getTimeHours().c_str()));
   } else {
     mesh.StandardInit();
+  }
+}
 TIMESTEP {
   static int i=0;
   static int t=0;
   static int ncells;
   if (!batch) {
     UserMessage(QString("Time: %1").arg(mesh.getTimeHours().c_str()),0);
+  }
   ncells=mesh.NCells();
   double dh;
   if(DynamicCellsP()) {
     dh = mesh.DisplaceNodes();
     // Only allow for node insertion, cell division and cell growth
     // if the system has equillibrized
     // i.e. cell wall tension equillibrization is much faster
     // than biological processes, including division, cell wall yielding
     // and cell expansion
     mesh.InsertNodes(); // (this amounts to cell wall yielding)
     if ( (-dh) < par.energy_threshold) {
       mesh.IncreaseCellCapacityIfNecessary();
       mesh.DoCellHouseKeeping();
       //mesh.LoopCurrentCells(mem_fun(&plugin->CellHouseKeeping)); // this includes cell division
       // Reaction diffusion
       mesh.ReactDiffuse(par.rd_dt);
       t++;
       Plot(par.resize_stride);
+    }
   } else {
     mesh.ReactDiffuse(par.rd_dt);
     Plot(par.resize_stride);
+  }
   i++;
   return mesh.getTime();
+}
 /* Called if a cell is clicked */
 void Cell::OnClick(QMouseEvent *e) {
 void Cell::OnClick(QMouseEvent *e)
+{
   e = NULL; // use assignment merely to obviate compilation warning
+}
 /* Custom message handler - Default appends a newline character to the end of each line. */
 void vlMessageOutput(QtMsgType type, const char *msg)
+{
   switch (type) {
   case QtDebugMsg:
@@ @@ -308,60 +301,56 @@ void vlMessageOutput(QtMsgType type, con @@
   case QtFatalMsg:
     //fprintf(stderr, "Fatal: %s\n", msg);
     cerr << "Fatal: " << msg << flush;
     abort();
+  }
+}
 Parameter par;
 int main(int argc,char **argv) {
   try {
     int c;
     char *leaffile=0;
     char *modelfile=0;
     while (1) {
       //int this_option_optind = optind ? optind : 1;
       int option_index = 0;
       static struct option long_options[] = {
 	{"batch", no_argument, NULL, 'b'},
 	{"leaffile", required_argument, NULL, 'l'},
 	{"model", required_argument, NULL, 'm'}
       };
       // short option 'p' creates trouble for non-commandline usage on MacOSX. Option -p changed to -P (capital)
       static char *short_options = "blm";
       c = getopt_long (argc, argv, "bl:m:",
 		       long_options, &option_index);
       if (c == -1)
 	break;
       if (c==0) {
 	printf ("option %s", long_options[option_index].name);
 	if (optarg)
 	  printf (" with arg %s", optarg);
 	printf ("\n");
 	c = short_options[option_index];
+      }
       switch (c) {
       case 'b':
 	cerr << "Running in batch mode\n";
 	batch=true;
 	break;
       case 'l':
 	leaffile=strdup(optarg);
 	if (!leaffile) {
 	  throw("Out of memory");
+	}
 	printf("Reading leaf state file '%s'\n", leaffile);
@@ @@ -370,93 +359,87 @@ int main(int argc,char **argv) { @@
       case 'm':
 	modelfile=strdup(optarg);
 	if (!modelfile) {
 	  throw("Out of memory");
+	}
 	break;
       case '?':
 	break;
       default:
 	printf ("?? getopt returned character code 0%o ??\n", c);
+      }
+    }
     if (optind < argc) {
       printf ("non-option ARGV-elements: ");
       while (optind < argc)
 	printf ("%s ", argv[optind++]);
       printf ("\n");
+    }
     bool useGUI = !batch;
     qInstallMsgHandler(vlMessageOutput); // custom message handler
     QApplication app(argc,argv,useGUI);
     QPalette tooltippalette = QToolTip::palette();
     QColor transparentcolor = QColor(tooltippalette.brush(QPalette::Window).color());
     tooltippalette.setBrush (QPalette::Window, QBrush (transparentcolor) );
     QToolTip::setPalette( tooltippalette );
     QGraphicsScene canvas(0,0,8000,6000);
     if (useGUI) {
       main_window=new Main(canvas, mesh);
       if ( QApplication::desktop()->width() > ((Main *)main_window)->width() + 10
 	   && QApplication::desktop()->height() > ((Main *)main_window)->height() +30 ) {
 	((Main *)main_window)->show();
 	((Main *)main_window)->resize( ((Main *)main_window)->sizeHint());
       } else {
         ((Main *)main_window)->showMaximized();
+      }
     } else {
       main_window=new MainBase(canvas, mesh);
+    }
     canvas.setSceneRect(QRectF());
     if (!batch) {
       QObject::connect( qApp, SIGNAL(lastWindowClosed()), qApp, SLOT(quit()) );
+    }
     // Install model or read catalogue of models
     ModelCatalogue model_catalogue(&mesh, useGUI?(Main *)main_window:0,modelfile);
     if (useGUI)
       model_catalogue.PopulateModelMenu();
     model_catalogue.InstallFirstModel();
     if (leaffile)
       main_window->Init(leaffile);
     Cell::SetMagnification(1);
     Cell::setOffset(0,0);
     main_window->FitLeafToCanvas();
     main_window->Plot();
     if (batch) {
       double t=0.;
       do {
 	t = main_window->TimeStep();
       } while (t < par.maxt);
     } else
       return app.exec();
   } catch (const char *message) {
     if (batch) {
       cerr << "Exception caught:" << endl;
       cerr << message << endl;
       abort();
     } else {
@@ @@ -474,6 +457,8 @@ int main(int argc,char **argv) { @@
       QString qmess(error_message.str().c_str());
       QMessageBox::critical(0, "I/O Error", qmess );
       abort();
+    }
+  }
+}
 /* finis */

src/apoplastitem.cpp

➞

Show inline comments

@@ @@ -29,47 +29,47 @@ @@
 #include "node.h"
 #include "apoplastitem.h"
 static const std::string _module_id("$Id$");
 ApoplastItem::ApoplastItem( Wall *w, QGraphicsScene *canvas )
 : QGraphicsLineItem( 0, canvas ), SimItemBase( w, canvas){
 	setColor();
 	// line with "PIN1"is a bit inside the cell wall
 	Vector edgevec = (*(w->N2())) - (*(w->N1()));
 	Vector perp = edgevec.Normalised().Perp2D();
 	Vector offs = Cell::Offset();
 	double factor = Cell::Factor();
 	Vector from = ( offs + *(w->N1()) ) * factor;
 	Vector to = ( offs + *(w->N2()) ) *factor;
 	setLine(( from.x ),
 			( from.y ),
 			( to.x ),
 			( to.y ) );
 	setZValue(12);
   : QGraphicsLineItem( 0, canvas ), SimItemBase( w, canvas){
   setColor();
   // line with "PIN1"is a bit inside the cell wall
   Vector edgevec = (*(w->N2())) - (*(w->N1()));
   Vector perp = edgevec.Normalised().Perp2D();
   Vector offs = Cell::Offset();
   double factor = Cell::Factor();
   Vector from = ( offs + *(w->N1()) ) * factor;
   Vector to = ( offs + *(w->N2()) ) *factor;
   setLine(( from.x ),
 	  ( from.y ),
 	  ( to.x ),
 	  ( to.y ) );
   setZValue(12);
+}
 void ApoplastItem::setColor(void) {
 	QColor diffcolor;
 	static const QColor purple("Purple");
 	static const QColor blue("blue");
 	Wall *w=&getWall();
 	double val = w->getApoplast(2);
   QColor diffcolor;
   static const QColor purple("Purple");
   static const QColor blue("blue");
 	diffcolor.setRgb( 0,0,(int)( ( val / (1 + val) )*255.));
 	setPen (QPen(diffcolor, 20) );
   Wall *w=&getWall();
   double val = w->getApoplast(2);
   diffcolor.setRgb( 0,0,(int)( ( val / (1 + val) )*255.));
   setPen (QPen(diffcolor, 20) );
+}
 void ApoplastItem::OnClick(QMouseEvent *e) {
   e = NULL; // merely to obviate compilation warnings
+}
 /* finis*/

src/apoplastitem.h

➞

Show inline comments

@@ @@ -20,29 +20,32 @@ @@
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _APOPLASTITEM_H_
 #define _APOPLASTITEM_H_
 #include <QGraphicsScene>
 #include <QGraphicsLineItem>
 #include <QPainter>
 #include <qpainter.h>
 #include <QMouseEvent>
 #include "simitembase.h"
 #include "wall.h"
 //! Shows transporter concentrations at one side of the wall
 class ApoplastItem : public QGraphicsLineItem, public SimItemBase
+{
 public:
 	ApoplastItem( Wall *n, QGraphicsScene *canvas );
 	virtual ~ApoplastItem() {}
 	Wall &getWall(void) const { return *class_cast<Wall*>(obj); }
 	void OnClick(QMouseEvent *e);
 	void setColor(void);
 private:
 	int wn;
  public:
   ApoplastItem( Wall *n, QGraphicsScene *canvas );
   virtual ~ApoplastItem() {}
   Wall &getWall(void) const { return *class_cast<Wall*>(obj); }
   void OnClick(QMouseEvent *e);
   void setColor(void);
  private:
   int wn;
 };
 #endif
 /* finis*/

src/build_models/auxingrowthplugin.cpp

➞

Show inline comments

@@ @@ -34,241 +34,238 @@ @@
 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)
+{
   parent_info = NULL; // merely to obviate compile time error
 	// Auxin distributes between parent and daughter according to area
 	double area1 = daughter1->Area(), area2 = daughter2->Area();
 	double tot_area = area1 + area2;
   // Auxin distributes between parent and daughter according to 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]);
   // After divisions, parent and daughter cells get a standard stock of PINs.
   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.);
+	}
   // Reset transporter values of parent and daughter
   QList<WallBase *> walls;
   foreach(WallBase *w, walls) {
     w->setTransporter(daughter1, 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->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);
   // Red: PIN1
   // Green: Auxin
   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.), 0);
+}
 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->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);
+	}
 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->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);
+  }
+}
 void AuxinGrowthPlugin::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
 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;
 			return;
 		} else {
 			return;
+		}
+	}
   // 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;
       return;
     } else {
       return;
+    }
+  }
 	if (w->C1()->BoundaryPolP()) {
   if (w->C1()->BoundaryPolP()) {
 		if (w->AuxinSource()) {
 			double aux_flux = par->leaf_tip_source * w->Length();
 			dchem_c2[0] += aux_flux;
 			return;
 		} else {
     if (w->AuxinSource()) {
       double aux_flux = par->leaf_tip_source * w->Length();
       dchem_c2[0] += aux_flux;
       return;
     } else {
-			if (w->AuxinSink()) {
+      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));
 	// 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;
+		}
 	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;
   // 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)
   // 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)) );
   // (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)) );
   // 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;
   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()) {
 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[0] = 0.; dw2[0] = 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);
       // 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);
+      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;
       dw2[1] = 0.;
       return;
 		} else {
 			dw1[0]=dw2[0]=dw1[1]=dw2[1];
 			return;
+		}
     } else {
       dw1[0]=dw2[0]=dw1[1]=dw2[1];
       return;
+    }
+  }
     if (w->C1()->BoundaryPolP()) {
 		if (w->AuxinSink())  {
   if (w->C1()->BoundaryPolP()) {
     if (w->AuxinSink())  {
-			dw1[0] = 0.; dw2[0] = 0.;
+      dw1[0] = 0.; dw2[0] = 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);
       // 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;
       dw1[1] = 0.;
       return;
 		}  else {
 			dw1[0]=dw2[0]=dw1[1]=dw2[1];
 			return;
+		}
     }  else {
       dw1[0]=dw2[0]=dw1[1]=dw2[1];
       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)
   // 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.;
   double dPijdt1=0., dPijdt2=0.;
     // normal cell
     double  auxin2 = w->C2()->Chemical(0);
     double receptor_level1 = auxin2 * par->r / (par->kr + auxin2);
   // normal cell
   double  auxin2 = w->C2()->Chemical(0);
   double receptor_level1 = auxin2 * par->r / (par->kr + auxin2);
     dPijdt1 =
 	// exocytosis regulated
   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);
   double  auxin1 = w->C1()->Chemical(0);
   double receptor_level2 = auxin1 * par->r / (par->kr + auxin1);
     // normal cell
     dPijdt2 =
   // normal cell
   dPijdt2 =
 	// exocytosis regulated
 	par->k1 * w->C2()->Chemical(1) * receptor_level2 / ( par->km + w->C2()->Chemical(1) ) - par->k2 * w->Transporters2(1);
     // 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 */
   /* PIN1 of neighboring vascular cell inhibits PIN1 endocytosis */
     dw1[0] = 0.; dw2[0] = 0.;
     dw1[1] = dPijdt1;
     dw2[1] = dPijdt2;
   dw1[0] = 0.; dw2[0] = 0.;
   dw1[1] = dPijdt1;
   dw2[1] = dPijdt2;
+}
 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 receptor_level = nb_aux * par->r / (par->kr + nb_aux);
 	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:
 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));
 	dPidt = -par->k1 * c->ReduceCellAndWalls<double>( far_3_arg_mem_fun( *this, &AuxinGrowthPlugin::complex_PijAj ) ) + par->k2 * 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;
   double nb_aux = (nb->BoundaryPolP() && w->AuxinSink()) ? par->sam_auxin : nb->Chemical(0);
   double receptor_level = nb_aux * par->r / (par->kr + nb_aux);
 	// 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);
+	}
   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;
   // 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)
 /* finis */

src/build_models/auxingrowthplugin.h

➞

Show inline comments

@@ @@ -27,37 +27,39 @@ @@
 #include <QtGui>
 #include <QString>
 #include "../simplugin.h"
 class AuxinGrowthPlugin : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
   Q_OBJECT
   Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void) { return QString( "Auxin accumulation and growth" ); }
  public:
   virtual QString ModelID(void) { return QString( "Auxin accumulation and growth" ); }
 	// 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);
   // 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 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);
   // 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 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) { return 2; }
   // to be executed for coloring a cell
   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);
  private:
   double complex_PijAj(CellBase *here, CellBase *nb, Wall *w);
 };
 #endif
 /* finis */

src/build_models/meinhardtplugin.cpp

➞

Show inline comments

@@ @@ -38,93 +38,89 @@ void MeinhardtPlugin::OnDivide(ParentInf @@
   parent_info = NULL;
   daughter1 = daughter2 = NULL;
+}
 void MeinhardtPlugin::SetCellColor(CellBase *c, QColor *color) {
 	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");
 	} else {
 		double range_min = 0.;//, range_max = 1.;
 		if (c->Chemical(0)<range_min) {
 			MyWarning::warning("Whoops! Numerical instability!!");
 			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.) );
+		}
+	}
   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");
   } else {
     double range_min = 0.;//, range_max = 1.;
     if (c->Chemical(0)<range_min) {
       MyWarning::warning("Whoops! Numerical instability!!");
       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.) );
+    }
+  }
+}
 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 );
 	} else {
 		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);
 		} else {
 			c->EnlargeTargetArea(par->vessel_expansion_rate);
+		}
+	}
   // 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 );
   } else {
     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);
     } else {
       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
+  // 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;
+		}
     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;
+	}
   // 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) {
   w = NULL;
 	for (int c = 0;c<NChem();c++) {
 		dw1[c] = 0.; dw2[c] = 0.;
+    }
   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 Y = c->Chemical(0);
   double A = c->Chemical(1);
   double H = c->Chemical(2);
   double S = c->Chemical(3);
     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[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 );
+}
 Q_EXPORT_PLUGIN2(meinhardtplugin, MeinhardtPlugin)
 /* finis */

src/build_models/meinhardtplugin.h

➞

Show inline comments

@@ @@ -27,34 +27,36 @@ @@
 #include <QtGui>
 #include <QString>
 #include "../simplugin.h"
 class MeinhardtPlugin : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
   Q_OBJECT
     Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void) { return QString( "Meinhardt 1976, with growth" ); }
  public:
   virtual QString ModelID(void) { return QString( "Meinhardt 1976, with growth" ); }
 	// 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);
   // 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 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);
   // 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 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) { return 4; }
   // to be executed for coloring a cell
   virtual void SetCellColor(CellBase *c, QColor *color);
   // return number of chemicals
   virtual int NChem(void) { return 4; }
 };
 #endif
 /* finis */

src/build_models/testplugin.cpp

➞

Show inline comments

@@ @@ -39,27 +39,27 @@ void TestPlugin::OnDivide(ParentInfo *pa @@
   parent_info = NULL;
   daughter1 = daughter2 = NULL;
+}
 void TestPlugin::SetCellColor(CellBase *c, QColor *color) {
 	static QStringList colors;
 	if (colors.size()==0) {
 		colors << "red" << "green" << "blue";
+	}
 	color->setNamedColor(colors[c->Index()%colors.size()]);
   static QStringList colors;
   if (colors.size()==0) {
     colors << "red" << "green" << "blue";
+  }
   color->setNamedColor(colors[c->Index()%colors.size()]);
+}
 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) {
   w = NULL;
   dchem_c1 = dchem_c2 = NULL;
+}
@@ @@ -72,6 +72,8 @@ void TestPlugin::WallDynamics(Wall *w, d @@
 void TestPlugin::CellDynamics(CellBase *c, double *dchem) {
   c = NULL;
   dchem=NULL;
+}
 Q_EXPORT_PLUGIN2(testplugin, TestPlugin)
 /* finis */

src/build_models/testplugin.h

➞

Show inline comments

@@ @@ -27,34 +27,36 @@ @@
 #include <QtGui>
 #include <QString>
 #include "../simplugin.h"
 class TestPlugin : public QObject, SimPluginInterface {
 	Q_OBJECT
 	Q_INTERFACES(SimPluginInterface);
   Q_OBJECT
   Q_INTERFACES(SimPluginInterface);
 public:
 	virtual QString ModelID(void) { return QString( "Test model" ); }
  public:
   virtual QString ModelID(void) { return QString( "Test model" ); }
 	// 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);
   // 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 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);
   // 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 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) { return 0; }
   // to be executed for coloring a cell
   virtual void SetCellColor(CellBase *c, QColor *color);
   // return number of chemicals
   virtual int NChem(void) { return 0; }
 };
 #endif
 /* finis */

src/build_models/translate_plugin.pl

➞

Show inline comments

@@ @@ -11,68 +11,70 @@ @@
 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;
     #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;
+    }
 	# 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;
     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;
     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 @@
     s/\bplugin\b\.h/plugin_tl\.h/g;
     s/\bplugin\b\.cpp/plugin_tl\.cpp/g;
     print opfile;
+}
 #finis

src/canvas.cpp

➞

Show inline comments

@@ @@ -16,14 +16,12 @@ @@
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <QDebug>
 #include <string>
 #include <QGraphicsScene>
 #include <QGraphicsView>
 #include <qdatetime.h>
 #include <q3mainwindow.h>
 #include <qstatusbar.h>
@@ @@ -118,39 +116,39 @@ void FigureEditor::clear() @@
   QList<QGraphicsItem *>::Iterator it = list.begin();
   for (; it != list.end(); ++it) {
     delete *it;
+  }
+}
  void FigureEditor::wheelEvent(QWheelEvent *event)
+ {
    scaleView(pow((double)2, -event->delta() / 240.0));
+ }
 void FigureEditor::wheelEvent(QWheelEvent *event)
+{
   scaleView(pow((double)2, -event->delta() / 240.0));
+}
 void FigureEditor::scaleView (qreal scaleFactor)
+{
   qreal factor = matrix().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)). width();
   if (factor < 0.07 || factor > 100) return;
   scale (scaleFactor, scaleFactor);
+}
 void FigureEditor::Save(const char *fname, const char *format, int sizex, int sizey) {
     QImage *image = new QImage(sizex, sizey, QImage::Format_RGB32);
     image->fill(QColor(Qt::white).rgb());
     QPainter *painter=new QPainter(image);
     render(painter);
     image->save(QString(fname),format);
     delete painter;
     delete image;
 void FigureEditor::Save(const char *fname, const char *format, int sizex, int sizey)
+{
   QImage *image = new QImage(sizex, sizey, QImage::Format_RGB32);
   image->fill(QColor(Qt::white).rgb());
   QPainter *painter=new QPainter(image);
   render(painter);
   image->save(QString(fname),format);
   delete painter;
   delete image;
+}
 //void FigureEditor::contentsMousePressEvent(QMouseEvent* e)
 void FigureEditor::mousePressEvent(QMouseEvent* e)
+{
   static QList<Node*> selected;
   emit MousePressed();
   //QPointF p = matrix().inverted().map(e->pos());
@@ @@ -158,62 +156,61 @@ void FigureEditor::mousePressEvent(QMous @@
 #ifdef QDEBUG
   qDebug() << endl << "MousePressEvent location: (" << p.x() << "," << p.y() << ")." << endl;
   qDebug() << "Magnification:  " << Cell::Magnification() << endl;
   qDebug() << "Offsets:  " << Cell::Offset() << endl;
 #endif
   QList<QGraphicsItem *> l=scene()->items(p);
 #ifdef QDEBUG
   qDebug() << "MousePressEvents, items: " << l.size() << endl;
   qDebug() << "Mouse button modifier: " << e->modifiers() << endl;
 #endif
     if (e->button()==Qt::RightButton || l.size()==0) {
       //cerr << "Drawing an intersection line from " << p.x() << ", " << p.y() << endl;
       intersection_line = new QGraphicsLineItem( 0, scene() );
       intersection_line->setPen( QPen( QColor("red"), 3, Qt::DashLine ) );
       intersection_line->setLine( QLineF(p,p) );
       intersection_line->setZValue( 100 );
       intersection_line->show();
+    }
     for (QList<QGraphicsItem *>::Iterator it=l.begin(); it!=l.end(); ++it) {
       #ifdef QDEBUG
       qDebug() << typeid(**it).name() << endl;
       #endif
   if (e->button()==Qt::RightButton || l.size()==0) {
     //cerr << "Drawing an intersection line from " << p.x() << ", " << p.y() << endl;
     intersection_line = new QGraphicsLineItem( 0, scene() );
     intersection_line->setPen( QPen( QColor("red"), 3, Qt::DashLine ) );
     intersection_line->setLine( QLineF(p,p) );
     intersection_line->setZValue( 100 );
     intersection_line->show();
+  }
   for (QList<QGraphicsItem *>::Iterator it=l.begin(); it!=l.end(); ++it) {
 #ifdef QDEBUG
     qDebug() << typeid(**it).name() << endl;
 #endif
     if ( !strcmp(typeid(**it).name(),"8NodeItem")) {
       if ( !strcmp(typeid(**it).name(),"8NodeItem")) {
 	stringstream data_strstream;
 	data_strstream << (dynamic_cast<NodeItem*>(*it))->getNode();
 	dynamic_cast<Main *>(parent())->UserMessage(QString(data_strstream.str().c_str()));
 	(dynamic_cast<NodeItem*>(*it))->OnClick(e->button());
       stringstream data_strstream;
       data_strstream << (dynamic_cast<NodeItem*>(*it))->getNode();
       dynamic_cast<Main *>(parent())->UserMessage(QString(data_strstream.str().c_str()));
       (dynamic_cast<NodeItem*>(*it))->OnClick(e->button());
+    }
     else
       if ( !strcmp(typeid(**it).name(),"8CellItem") ) {
 	Cell &c=((dynamic_cast<CellItem *>(*it))->getCell());
 	// OnClick to be defined in end-user code
 	c.OnClick(e);
       } else {
 	if ( !strcmp(typeid(**it).name(),"8WallItem") ) {
 	  (dynamic_cast<WallItem *>(*it))->OnClick(e);
+	}
+      }
       else
 	if ( !strcmp(typeid(**it).name(),"8CellItem") ) {
 	  Cell &c=((dynamic_cast<CellItem *>(*it))->getCell());
 	  // OnClick to be defined in end-user code
 	  c.OnClick(e);
 	} else {
 	  if ( !strcmp(typeid(**it).name(),"8WallItem") ) {
 	    (dynamic_cast<WallItem *>(*it))->OnClick(e);
+	  }
+	}
+    }
+  }
   FullRedraw();
   moving = 0;
+}
 //void FigureEditor::contentsMouseMoveEvent(QMouseEvent* e)
 void FigureEditor::mouseMoveEvent(QMouseEvent* e)
+{
   // User choose "rotation mode" and we can rotate the object around its center of mass
   if (dynamic_cast<Main *>(parent())->RotationModeP()) {
@@ @@ -221,120 +218,120 @@ void FigureEditor::mouseMoveEvent(QMouse @@
     p.setX(p.x() / Cell::Magnification());
     p.setY(p.y() / Cell::Magnification());
     // get object's center of mass
     QPointF rotation_midpoint = mesh.Centroid()*Cell::Factor() - Cell::Offset();
     // calculate rotation angle
     double dy = (rotation_midpoint.y() - p.y());
     double dx = (rotation_midpoint.x() - p.x());
     double new_rot_angle = atan2(dx, dy);
     double d_alpha = new_rot_angle - rot_angle;
     rot_angle = new_rot_angle;
     mesh.Rotate(d_alpha, ( Vector(rotation_midpoint) + Cell::Offset() ) / Cell::Factor() );
     dynamic_cast<Main *>(parent())->Plot(0);
-	  FullRedraw();
+    FullRedraw();
     return;
+  }
   if ( moving ) {
     QPointF p = mapToScene(e->pos());
     moving->userMove(p.x() - moving_start.x(),
 		     p.y() - moving_start.y());
     moving_start = p;
     scene()->update();
+  }
   //cerr << "event";
   // keep track of intersection line to interactively cut a growing leaf
   if ( intersection_line ) {
     QPointF sp = intersection_line -> line().p1(); // startpoint
     QPointF ep = mapToScene(e->pos()); // endpoint
     intersection_line -> setLine( QLineF(sp, ep) );
     scene()->update();
     // Need this for Mac
     FullRedraw();
+    }
+  }
+}
 //void FigureEditor::contentsMouseReleaseEvent(QMouseEvent* e)
 void FigureEditor::mouseReleaseEvent(QMouseEvent* e)
+{
   emit MouseReleased();
   // intersection line for leaf was finished now.
   if (e->button()==Qt::LeftButton) {
     if (intersection_line ) {
-      #ifdef QDEBUG
 #ifdef QDEBUG
       qDebug() << "Trying to cut leaf" << endl;
-      #endif
 #endif
       QPointF sp = intersection_line -> line().p1(); // startpoint
       QPointF ep = mapToScene(e->pos());
       intersection_line -> setLine( QLineF(sp, ep) );
       intersection_line -> show();
       vector <CellItem *> intersected_cells = getIntersectedCells();
       // no cells selected, do nothing
       if (intersected_cells.size()==0) {
-        #ifdef QDEBUG
 #ifdef QDEBUG
 	qDebug() << "No cells detected :-(" << endl;
-	#endif
 #endif
 	return;
+      }
       Vector startpoint = Vector(sp.x(), sp.y()) / Cell::Factor() - Cell::Offset();
       Vector endpoint = Vector(ep.x(), ep.y()) / Cell::Factor() - Cell::Offset();
       NodeSet *node_set = new NodeSet;
       for (vector<CellItem *>::iterator it = intersected_cells.begin();
 	   it != intersected_cells.end();
 	   it++) {
 	(*it)->setBrush(QBrush("purple"));
 	Cell &c=(*it)->getCell();
 	// sometimes the cell hasn't properly divided yet before the
 	// next division is called?  so check for it?  let's find a way
 	// to do this later. Note that this functionality currently
 	// might result in a segmentation fault for users who are
 	// quickly dragging and releasing division lines...
 	scene()->update();
 	#ifdef QDEBUG
 #ifdef QDEBUG
 	qDebug() << "Dividing Cell " << c.Index() << endl;
-	#endif
 #endif
 	c.DivideOverGivenLine( startpoint, endpoint, true, node_set);
+      }
       node_set->CleanUp();
       mesh.AddNodeSet(node_set);
       #ifdef QDEBUG
 #ifdef QDEBUG
       qDebug() << "Done DivideOverGivenLine" << endl;
-      #endif
 #endif
       mesh.TestIllegalWalls();
       // Do the actual cutting and removing
       if (intersected_cells.size()) {
 	mesh.CutAwayBelowLine( startpoint, endpoint );
 	// Correct flags of nodeset
 	for (
 	     NodeSet::iterator i = node_set->begin();
 	     i != node_set->end();
 	     i++) {
 	  (*i)->SetSAM();
@@ @@ -352,80 +349,80 @@ void FigureEditor::mouseReleaseEvent(QMo @@
 	      c++) {
 	  (*c)->SetBoundary(Cell::SAM);
+	}
-	#ifdef QDEBUG
 #ifdef QDEBUG
 	qDebug() << "Done CutAwayBelowLine" << endl;
-	#endif
 #endif
 	mesh.TestIllegalWalls();
 	mesh.RepairBoundaryPolygon();
-	#ifdef QDEBUG
 #ifdef QDEBUG
 	qDebug() << "Done RepairBoundaryPolygon" << endl;
-	#endif
 #endif
 	mesh.TestIllegalWalls();
 	mesh.CleanUpWalls();
-	#ifdef QDEBUG
 #ifdef QDEBUG
 	qDebug() << "Done CleanUpWalls" << endl;
-	#endif
 #endif
 	mesh.TestIllegalWalls();
+      }
       dynamic_cast<Main *>(parent())->Plot();
         #ifdef QDEBUG
 	qDebug() << "NodeSet of cutting line: " << *node_set << endl;
 	#endif
 #ifdef QDEBUG
       qDebug() << "NodeSet of cutting line: " << *node_set << endl;
 #endif
+    }
   } else
     if (e->button()==Qt::RightButton) {
       if (intersection_line /* && !angle_line*/) {
 	QPointF p = mapToScene(e->pos());
 	QPointF sp = intersection_line->line().p1();
 	viewport()->setMouseTracking( TRUE );
+      }
+    }
+}
 // returns a vector of pointer to cells colliding with intersection line
 vector <CellItem *> FigureEditor::getIntersectedCells(void) {
 vector <CellItem *> FigureEditor::getIntersectedCells(void)
+{
   vector <CellItem *> colliding_cells;
   QList<QGraphicsItem *> l = intersection_line->collidingItems( );
   #ifdef QDEBUG
 #ifdef QDEBUG
   qDebug() <<  "l.size() = " << l.size() << endl;
-  #endif
 #endif
   for (QList<QGraphicsItem *>::Iterator it=l.begin(); it!=l.end(); ++it) {
     #ifdef QDEBUG
 #ifdef QDEBUG
     qDebug() << typeid(**it).name() << endl;
     #endif
 #endif
     if ( !strcmp(typeid(**it).name(),"8CellItem") ) {
       colliding_cells.push_back(dynamic_cast<CellItem *>(*it));
+    }
+  }
   delete intersection_line;
   intersection_line = 0;
   return colliding_cells;
+}
 void FigureEditor::FullRedraw(void) {
 	QList<QRectF> rl;
 	rl << sceneRect();
 	updateScene(rl);
 void FigureEditor::FullRedraw(void)
+{
   QList<QRectF> rl;
   rl << sceneRect();
   updateScene(rl);
+}
 NodeItem *FigureEditor::selectedNodeItem(QList<QGraphicsItem *> graphicItems) const
+{
   NodeItem *nodeItem = 0;
@@ @@ -462,59 +459,59 @@ Main::Main(QGraphicsScene& c, Mesh &m, Q @@
   Q3MainWindow(parent,name,f),
   MainBase(c,m),
   mesh(m)
+{
   editor = new FigureEditor(canvas,mesh, this);
-  #ifdef QDEBUG
 #ifdef QDEBUG
   qDebug() << "Interactive = " << editor->isEnabled();
-  #endif
 #endif
   working_dir = 0;
   QObject::connect( editor, SIGNAL(MousePressed()), this, SLOT(PauseIfRunning()));
   QObject::connect( editor, SIGNAL(MouseReleased()), this, SLOT(ContIfRunning()));
   QMenuBar* menu = menuBar();
   Q3PopupMenu* file = new Q3PopupMenu( menu );
 	file->insertItem("&Read leaf", this, SLOT(readStateXML()));
 	file->insertItem("&Save leaf", this, SLOT(saveStateXML()));
 	file->insertItem("Snapshot", this, SLOT(snapshot()), Qt::CTRL+Qt::SHIFT+Qt::Key_S);
   file->insertItem("&Read leaf", this, SLOT(readStateXML()));
   file->insertItem("&Save leaf", this, SLOT(saveStateXML()));
   file->insertItem("Snapshot", this, SLOT(snapshot()), Qt::CTRL+Qt::SHIFT+Qt::Key_S);
   file->insertSeparator();
   file->insertItem("Read next leaf", this, SLOT(readNextStateXML()), Qt::Key_PageDown);
   file->insertItem("Read previous leaf", this, SLOT(readPrevStateXML()), Qt::Key_PageUp);
   file->insertItem("Read last leaf", this, SLOT(readLastStateXML()), Qt::Key_End);
   file->insertItem("Read first leaf", this, SLOT(readFirstStateXML()), Qt::Key_Home);
    file->insertSeparator();
 	file->insertItem("Read next leaf", this, SLOT(readNextStateXML()), Qt::Key_PageDown);
 	file->insertItem("Read previous leaf", this, SLOT(readPrevStateXML()), Qt::Key_PageUp);
 	file->insertItem("Read last leaf", this, SLOT(readLastStateXML()), Qt::Key_End);
 	file->insertItem("Read first leaf", this, SLOT(readFirstStateXML()), Qt::Key_Home);
 	file->insertSeparator();
 	file->insertItem("&Print...", this, SLOT(print()), Qt::CTRL+Qt::Key_P);
 	file->insertSeparator();
 	file->insertItem("E&xit", qApp, SLOT(quit()), Qt::CTRL+Qt::Key_Q);
 	menu->insertItem("&File", file);
 	Q3PopupMenu* edit = new Q3PopupMenu( menu );
   file->insertSeparator();
   file->insertItem("&Print...", this, SLOT(print()), Qt::CTRL+Qt::Key_P);
   file->insertSeparator();
   file->insertItem("E&xit", qApp, SLOT(quit()), Qt::CTRL+Qt::Key_Q);
   menu->insertItem("&File", file);
   Q3PopupMenu* edit = new Q3PopupMenu( menu );
   edit->insertItem("Reset Chemicals and Transporters", this, SLOT( CleanMesh()), Qt::CTRL+Qt::Key_R );
 	edit->insertItem("Reset Chemicals", this, SLOT( CleanMeshChemicals()) );
 	edit->insertItem("Reset Transporters", this, SLOT( CleanMeshTransporters()) );
   edit->insertItem("Reset Chemicals", this, SLOT( CleanMeshChemicals()) );
   edit->insertItem("Reset Transporters", this, SLOT( CleanMeshTransporters()) );
   edit->insertItem("Randomize PIN1 Transporters", this, SLOT( RandomizeMesh()) );
   edit->insertItem("Cut away SAM", this, SLOT( CutSAM() ));
   menu->insertItem("&Edit", edit);
   run = new Q3PopupMenu( menu );
   running = false;
-	paused_id = run->insertItem("&Simulation paused", this, SLOT(togglePaused()), Qt::Key_S);
+  paused_id = run->insertItem("&Simulation paused", this, SLOT(togglePaused()), Qt::Key_S);
   run->setItemChecked(paused_id, FALSE);
   menu->insertItem("&Run", run);
   view = new Q3PopupMenu( menu );
-	view->insertItem("&Zoom in", this, SLOT(zoomIn()), Qt::CTRL+Qt::Key_Equal);
+  view->insertItem("&Zoom in", this, SLOT(zoomIn()), Qt::CTRL+Qt::Key_Equal);
   view->insertItem("Zoom &out", this, SLOT(zoomOut()), Qt::CTRL+Qt::Key_Minus);
 	view->insertSeparator();
 	com_id = view->insertItem("Show cell &centers", this, SLOT(toggleShowCellCenters()));
   view->insertSeparator();
   com_id = view->insertItem("Show cell &centers", this, SLOT(toggleShowCellCenters()));
   view->setItemChecked(com_id, FALSE);
   mesh_id = view->insertItem("Show &nodes", this, SLOT(toggleShowNodes()), Qt::CTRL+Qt::SHIFT+Qt::Key_N);
   view->setItemChecked(mesh_id, TRUE);
   node_number_id = view->insertItem("Show node numbers", this, SLOT(toggleNodeNumbers()), Qt::CTRL+Qt::SHIFT+Qt::Key_M);
   view->setItemChecked(node_number_id, FALSE);
@@ @@ -527,92 +524,89 @@ Main::Main(QGraphicsScene& c, Mesh &m, Q @@
   cell_axes_id = view->insertItem("Show cell &axes", this, SLOT(toggleCellAxes()));
   cell_strain_id = view->insertItem("Show cell &strain", this, SLOT(toggleCellStrain()));
   view->setItemChecked(cell_axes_id, FALSE);
   fluxes_id = view->insertItem("Show &fluxes", this, SLOT(toggleShowFluxes()));
   view->setItemChecked(fluxes_id, FALSE);
   cell_walls_id = view->insertItem("Show transporters", this, SLOT(toggleShowWalls()));
 	view->setItemChecked(cell_walls_id, FALSE);
 	apoplasts_id = view->insertItem("Show apoplasts", this, SLOT(toggleShowApoplasts()));
   view->setItemChecked(cell_walls_id, FALSE);
   apoplasts_id = view->insertItem("Show apoplasts", this, SLOT(toggleShowApoplasts()));
   view->setItemChecked(apoplasts_id, FALSE);
  	view->insertSeparator();
 	  only_boundary_id = view->insertItem("Show only leaf &boundary", this, SLOT(toggleLeafBoundary()));
 	view->insertSeparator();
 	movie_frames_id = view->insertItem("Start saving movie &frames", this, SLOT(toggleMovieFrames()));
   view->insertSeparator();
   only_boundary_id = view->insertItem("Show only leaf &boundary", this, SLOT(toggleLeafBoundary()));
   view->insertSeparator();
   movie_frames_id = view->insertItem("Start saving movie &frames", this, SLOT(toggleMovieFrames()));
   view->setItemChecked(movie_frames_id, par.movie);
 	view->setItemChecked(only_boundary_id, FALSE);
   view->setItemChecked(only_boundary_id, FALSE);
   menu->insertItem("&View", view);
   options = new Q3PopupMenu( menu );
   dyn_cells_id = options->insertItem("Cell growth", this, SLOT(toggleDynCells()));
   options->setItemChecked(dyn_cells_id, true);
   options->insertItem("Edit &parameters", this, SLOT(EditParameters()), Qt::CTRL+Qt::Key_E);
   rotation_mode_id = options->insertItem("Rotate leaf", this, SLOT(EnterRotationMode()), Qt::CTRL + Qt::SHIFT + Qt::Key_R);
   options->setItemChecked(rotation_mode_id, false);
   menu->insertItem("&Options",options);
 	// Menu of models
 	modelmenu = new QMenu( menu );
 	menu->insertItem("&Models", modelmenu);
   // Menu of models
   modelmenu = new QMenu( menu );
   menu->insertItem("&Models", modelmenu);
   menu->insertSeparator();
   helpmenu = new Q3PopupMenu( menu );
   tooltips_id = helpmenu->insertItem("Show Cell&Info", this, SLOT(Refresh()));
   helpmenu->setItemChecked(tooltips_id, true);
   helpmenu->insertSeparator();
   helpmenu->insertItem("&About", this, SLOT(help()) ); //, Key_F1);
   menu->insertItem("&Help",helpmenu);
   statusBar();
   setCentralWidget(editor);
   printer = 0;
   init();
   // Start timer which repetitively invokes
   // a simulation time step
   timer = new QTimer( this );
   connect( timer, SIGNAL(timeout()), SLOT(TimeStepWrap()) );
   stopSimulation();
   statusBar()->addWidget(new QLabel("Ready."));
   setCaption(caption);
   gifanim = 0;
 	infobar = new InfoBar();
 	addDockWindow(infobar);
   infobar = new InfoBar();
   addDockWindow(infobar);
+}
 void Main::RefreshInfoBar(void) {
 	infobar->SetText(mesh.ModelID());
 void Main::RefreshInfoBar(void)
+{
   infobar->SetText(mesh.ModelID());
+}
 void Main::UserMessage(QString message, int timeout) {
 void Main::UserMessage(QString message, int timeout)
+{
   statusBar()->showMessage(message, timeout);
+}
 void Main::init()
+{
   clear();
   static int r=24;
   srand(++r);
   mainCount++;
+}
 Main::~Main()
+{
   delete printer;
   if ( !--mainCount ) {
@@ @@ -627,223 +621,225 @@ void Main::newView() @@
   qApp->setMainWidget(m);
   m->show();
   qApp->setMainWidget(0);
+}
 void Main::EditParameters() {
 void Main::EditParameters()
+{
   ParameterDialog *pardial = new ParameterDialog(this, "stridediag");
   // Make sure the values in the parameter dialog are updated after a file is read
   // each method changing the parameters (reading XML or PAR files) should
   // emit this signal
   QObject::connect(   this, SIGNAL( ParsChanged() ), pardial, SLOT( Reset() ) );
+}
 void Main::savePars() {
 void Main::savePars()
+{
   stopSimulation();
   Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );
   fd->setMode( Q3FileDialog::AnyFile );
   fd->setFilter( "Parameter files (*.par)");
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     ofstream parfile((const char *)fileName);
     par.Write(parfile);
+  }
   startSimulation();
+}
 void Main::readPars() {
 void Main::readPars()
+{
   stopSimulation();
   Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );
   fd->setMode( Q3FileDialog::ExistingFile );
   fd->setFilter( "Parameter files (*.par)");
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     par.Read((const char *)fileName);
+  }
   emit ParsChanged();
   /* if (timer_active)
      timer->start( 0 );*/
+}
 void Main::saveStateXML() {
 void Main::saveStateXML()
+{
   stopSimulation();
   Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );
   fd->setMode( Q3FileDialog::AnyFile );
   fd->setFilter( "XML (*.xml)");
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     if ( QFile::exists( fileName ) &&
 	 QMessageBox::question(
 			       this,
 			       tr("Overwrite File? -- Leaf Growth"),
 			       tr("A file called %1 already exists."
 				  "Do you want to overwrite it?")
 			       .arg( fileName ),
 			       tr("&Yes"), tr("&No"),
 			       QString::null, 1, 1 ) ) {
       return saveStateXML();
     } else {
       mesh.XMLSave((const char *)fileName, XMLSettingsTree());
+    }
+  }
+}
 void Main::snapshot() {
 void Main::snapshot()
+{
   stopSimulation();
   Q3FileDialog *fd = new Q3FileDialog( this, "Save snapshot", TRUE );
   fd->setMode( Q3FileDialog::AnyFile );
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     if ( QFile::exists( fileName ) &&
 	 QMessageBox::question(
 			       this,
 			       tr("Overwrite File? -- Leaf Growth"),
 			       tr("A file called %1 already exists."
 				  "Do you want to overwrite it?")
 			       .arg( fileName ),
 			       tr("&Yes"), tr("&No"),
 			       QString::null, 1, 1 ) ) {
       return snapshot();
     } else {
       // extract extension from filename
 		QString extension = getExtension(fileName);
 		// Save bitmaps at 1024x768
 		Save((const char *)fileName, extension, 1024, 768);
       QString extension = getExtension(fileName);
       // Save bitmaps at 1024x768
       Save((const char *)fileName, extension, 1024, 768);
+    }
+  }
+}
 void Main::readPrevStateXML() {
 void Main::readPrevStateXML()
+{
   // if we have already read a file, read the next file
   if (!currentFile.isEmpty() && working_dir) {
     QString next_file;
     QStringList xml_files = working_dir->entryList("*.xml");
     QString currentFile_nopath = currentFile.section( '/', -1 );
     QString currentFile_path = currentFile.section( '/', 0, -2 );
     QList<QString>::iterator f = xml_files.find( currentFile_nopath );
     if (f == xml_files.end()) {
       return;
+    }
     if (f==xml_files.begin()) {
       QMessageBox mb( "Read previous leaf",
 		      "No more files",
 		      QMessageBox::Information,
 		      QMessageBox::Ok | QMessageBox::Default,
 		      QMessageBox::NoButton,
 		      QMessageBox::NoButton);
       mb.exec();
       return;
+    }
     next_file = *(--f);
     next_file = currentFile_path+"/"+next_file;
     readStateXML((const char *)next_file);
+  }
+}
 int Main::readStateXML(const char *filename, bool geometry, bool pars, bool simtime) {
 int Main::readStateXML(const char *filename, bool geometry, bool pars, bool simtime)
+{
   try {
     xmlNode *settings;
     mesh.XMLRead((const char *)filename, &settings, geometry, pars, simtime);
-    #ifdef QDEBUG
 #ifdef QDEBUG
     qDebug() << "Reading done."<< endl;
-    #endif
 #endif
     XMLReadSettings(settings);
     xmlFree(settings);
     Cell::SetMagnification(1);
     Cell::setOffset(0,0);
     FitLeafToCanvas();
     currentFile =  QString(filename);
     Plot();
     QString status_message = QString("Successfully read leaf from file %1. Time is %2 h.").arg(currentFile).arg(mesh.getTimeHours().c_str());
     cerr << status_message.toStdString() << endl;
-	setCaption(caption_with_file.arg(filename));
+    setCaption(caption_with_file.arg(filename));
     statusBar()->message(status_message);
     emit ParsChanged();
-    #ifdef QDEBUG
 #ifdef QDEBUG
     qDebug() << "Done. Returning 0." << endl;
-    #endif
 #endif
     return 0;
   } catch (const char *error_message) {
     QMessageBox mb( "Read leaf from XML file",
 		    QString(error_message),
 		    QMessageBox::Critical,
 		    QMessageBox::Ok | QMessageBox::Default,
 		    Qt::NoButton,
 		    Qt::NoButton);
     mb.exec();
     return 1;
+  }
+}
 void Main::readNextStateXML() {
 void Main::readNextStateXML()
+{
   // if we have already read a file, read the next file
   if (!currentFile.isEmpty() && working_dir) {
     QString next_file;
     QStringList xml_files = working_dir->entryList("*.xml");
     QString currentFile_nopath = currentFile.section( '/', -1 );
     QString currentFile_path = currentFile.section( '/', 0, -2 );
     QList<QString>::iterator f = xml_files.find( currentFile_nopath );
     if (f == xml_files.end()) {
       return;
+    }
     ++f;
     if (f==xml_files.end()) {
       QMessageBox mb( "Read next leaf",
 		      "No more files",
 		      QMessageBox::Information,
 		      QMessageBox::Ok | QMessageBox::Default,
@@ @@ -854,82 +850,79 @@ void Main::readNextStateXML() { @@
+    }
     next_file = *f;
     next_file = currentFile_path+"/"+next_file;
     readStateXML((const char*)next_file);
+  }
+}
 void Main::readLastStateXML() {
 void Main::readLastStateXML()
+{
   // if we have already read a file, read the next file
   if (!currentFile.isEmpty() && working_dir) {
     QString next_file;
     QStringList xml_files = working_dir->entryList("*.xml");
     QString currentFile_nopath = currentFile.section( '/', -1 );
     QString currentFile_path = currentFile.section( '/', 0, -2 );
     next_file = xml_files.back();
     next_file = currentFile_path+"/"+next_file;
     readStateXML((const char*)next_file);
+  }
+}
 void Main::readFirstStateXML() {
 void Main::readFirstStateXML()
+{
   // if we have already read a file, read the next file
   if (!currentFile.isEmpty() && working_dir) {
     QString next_file;
     QStringList xml_files = working_dir->entryList("*.xml");
     QString currentFile_nopath = currentFile.section( '/', -1 );
     QString currentFile_path = currentFile.section( '/', 0, -2 );
     next_file = xml_files.front();
     next_file = currentFile_path+"/"+next_file;
     readStateXML((const char*)next_file);
+  }
+}
 void Main::readStateXML() {
 void Main::readStateXML()
+{
   //  extern Mesh mesh;
   stopSimulation();
-  #ifdef QDEBUG
 #ifdef QDEBUG
   qDebug() << "Trying to open an OptionFileDialog" << endl;
-  #endif
 #endif
   OptionFileDialog *fd = new OptionFileDialog( this, "read dialog", TRUE );
   fd->setMode( OptionFileDialog::ExistingFile );
   fd->setFilter( "XML files (*.xml)");
   if (working_dir) {
     fd->setDir(*working_dir);
+  }
   QString fileName;
   if ( fd->exec() == QDialog::Accepted ) {
     fileName = fd->selectedFile();
     if (working_dir) {
       delete working_dir;
+    }
     working_dir = fd->dir();
     if (readStateXML((const char *)fileName,fd->readGeometryP(), fd->readParametersP()) )
       return readStateXML(); // user can try again
+  }
+}
@@ @@ -944,324 +937,346 @@ void Main::help() @@
     ( "About",
       "<h3>Virtual Leaf</h3>"
       "<p>"
       "Leaf growth computer model <br>"
       "(c) 2005-2007, Roeland Merks <br>"
       "VIB Department Plant Systems Biology <br>"
-	 "Ghent, Belgium <br>"
+      "Ghent, Belgium <br>"
       "(c) 2008-2009, Roeland Merks <br>"
       "CWI/NCSB, Amsterdam, Netherlands <br>"
       "Pilot release for WUR/Biometris, 21-10-2009 <br>",
       QMessageBox::Information, 1, 0, 0, this, 0, FALSE );
   about->setButtonText( 1, "Dismiss" );
   about->show();
+}
   void Main::aboutQt()
+  {
     QMessageBox::aboutQt( this, "Virtual Leaf" );
+  }
 void Main::aboutQt(){
   QMessageBox::aboutQt( this, "Virtual Leaf" );
+}
   void Main::toggleShowCellCenters()
+  {
     Plot();
+  }
 void Main::toggleShowCellCenters()
+{
   Plot();
+}
   void Main::toggleShowWalls()
+  {
     Plot();
+  }
 void Main::toggleShowWalls()
+{
   Plot();
+}
 void Main::toggleShowApoplasts()
+{
-    Plot();
   Plot();
+}
   void Main::toggleShowNodes()
+  {
     Plot();
+  }
 void Main::toggleShowNodes()
+{
   Plot();
+}
   void Main::toggleNodeNumbers(void) {
     Plot();
+  }
 void Main::toggleNodeNumbers(void)
+{
   Plot();
+}
   void Main::toggleCellNumbers(void) {
     Plot();
+  }
 void Main::toggleCellNumbers(void)
+{
   Plot();
+}
   void Main::toggleCellAxes(void) {
     Plot();
+  }
   void Main::toggleCellStrain(void) {
     Plot();
+  }
 void Main::toggleCellAxes(void)
+{
   Plot();
+}
   void Main::toggleShowFluxes(void) {
     Plot();
+  }
 void Main::toggleCellStrain(void)
+{
   Plot();
+}
   void Main::toggleShowBorderCells(){
     Plot();
+  }
 void Main::toggleShowFluxes(void)
+{
   Plot();
+}
 void Main::toggleHideCells(void) {
 	Plot();
 	editor->FullRedraw();
 void Main::toggleShowBorderCells()
+{
   Plot();
+}
   void Main::toggleMovieFrames(){}
   void Main::toggleLeafBoundary(){}
 void Main::toggleHideCells(void)
+{
   Plot();
   editor->FullRedraw();
+}
 void Main::toggleMovieFrames(){}
 void Main::toggleLeafBoundary(){}
 void Main::toggleDynCells() {}
   void Main::toggleDynCells() {}
   void Main::startSimulation(void) {
     timer->start( 0 );
     statusBar()->message("Simulation started");
     running = true;
+  }
 void Main::startSimulation(void)
+{
   timer->start( 0 );
   statusBar()->message("Simulation started");
   running = true;
+}
   void Main::stopSimulation(void) {
     timer->stop();
     cerr << "Stopping simulation" << endl;
     statusBar()->message("Simulation paused");
     running = false;
 void Main::stopSimulation(void)
+{
   timer->stop();
   cerr << "Stopping simulation" << endl;
   statusBar()->message("Simulation paused");
   running = false;
+}
 void Main::togglePaused()
+{
   bool s = run->isItemChecked(paused_id);
   if (s) {
     cerr << "Calling start simulation" << endl;
     startSimulation();
   } else {
     cerr << "Calling stop simulation" << endl;
     stopSimulation();
+  }
+}
   void Main::togglePaused()
+  {
     bool s = run->isItemChecked(paused_id);
     if (s) {
       cerr << "Calling start simulation" << endl;
       startSimulation();
     } else {
       cerr << "Calling stop simulation" << endl;
       stopSimulation();
+    }
+  }
   void Main::setFluxArrowSize(int size) {
     flux_arrow_size = size/100.;
+  }
 void Main::setFluxArrowSize(int size)
+{
   flux_arrow_size = size/100.;
+}
   void Main::enlarge()
+  {
     canvas.setSceneRect( QRectF( 0,0, canvas.width()*4./3., canvas.height()*4./3.) );
+  }
 void Main::enlarge()
+{
   canvas.setSceneRect( QRectF( 0,0, canvas.width()*4./3., canvas.height()*4./3.) );
+}
   void Main::shrink()
+  {
     canvas.setSceneRect( QRectF( 0,0, canvas.width()*3/4, canvas.height()*3/4) );
+  }
 void Main::shrink()
+{
   canvas.setSceneRect( QRectF( 0,0, canvas.width()*3/4, canvas.height()*3/4) );
+}
   void Main::scale(double factor) {
     QMatrix m = editor->matrix();
     m.scale(factor, factor);
     editor->setMatrix( m );
+  }
 void Main::scale(double factor)
+{
   QMatrix m = editor->matrix();
   m.scale(factor, factor);
   editor->setMatrix( m );
+}
   void Main::zoomIn()
+  {
     QMatrix m = editor->matrix();
     m.scale( 1.1, 1.1 );
     editor->setMatrix( m );
+  }
 void Main::zoomIn()
+{
   QMatrix m = editor->matrix();
   m.scale( 1.1, 1.1 );
   editor->setMatrix( m );
+}
   void Main::zoomOut()
+  {
     QMatrix m = editor->matrix();
     m.scale( 0.9, 0.9 );
     editor->setMatrix( m );
+  }
 void Main::zoomOut()
+{
   QMatrix m = editor->matrix();
   m.scale( 0.9, 0.9 );
   editor->setMatrix( m );
+}
   void Main::print()
+  {
     if ( !printer ) printer = new QPrinter;
     if ( printer->setup(this) ) {
       //    extern Mesh mesh;
       Vector bbll,bbur;
       mesh.BoundingBox(bbll,bbur);
 void Main::print()
+{
   if ( !printer ) printer = new QPrinter;
   if ( printer->setup(this) ) {
     //    extern Mesh mesh;
     Vector bbll,bbur;
     mesh.BoundingBox(bbll,bbur);
       #ifdef QDEBUG
       qDebug() << "bbll = " << bbll << endl;
       qDebug() << "bbur = " << bbur << endl;
       #endif
       double cw = (bbur.x - bbll.x);
       double ch = (bbur.y - bbll.y);
       QPainter pp(printer);
       QRect vp=pp.viewport();
       #ifdef QDEBUG
       qDebug() << "Paper width = " << vp.width() << " x " << vp.height() << endl;
       #endif
 #ifdef QDEBUG
     qDebug() << "bbll = " << bbll << endl;
     qDebug() << "bbur = " << bbur << endl;
 #endif
     double cw = (bbur.x - bbll.x);
     double ch = (bbur.y - bbll.y);
     QPainter pp(printer);
     QRect vp=pp.viewport();
 #ifdef QDEBUG
     qDebug() << "Paper width = " << vp.width() << " x " << vp.height() << endl;
 #endif
       // Note that Cell is also translated...
       pp.translate(-bbur.x,-bbur.y);
       if (cw>ch) {
 	pp.scale(vp.width()/(2*cw*Cell::Magnification()), vp.width()/(2*cw*Cell::Magnification()));
       } else {
 	pp.scale(vp.height()/(2*ch*Cell::Magnification()), vp.height()/(2*ch*Cell::Magnification()));
+      }
       canvas.render(&pp, QRectF(), QRectF(0.,0.,canvas.width(),canvas.height()));
     // Note that Cell is also translated...
     pp.translate(-bbur.x,-bbur.y);
     if (cw>ch) {
       pp.scale(vp.width()/(2*cw*Cell::Magnification()), vp.width()/(2*cw*Cell::Magnification()));
     } else {
       pp.scale(vp.height()/(2*ch*Cell::Magnification()), vp.height()/(2*ch*Cell::Magnification()));
+    }
     canvas.render(&pp, QRectF(), QRectF(0.,0.,canvas.width(),canvas.height()));
+  }
+}
   void Main::TimeStepWrap(void) {
     static int t=0;
     TimeStep();
     t++;
     // check number of timesteps
     if (t==par.nit) {
       emit SimulationDone();
+    }
 void Main::TimeStepWrap(void)
+{
   static int t=0;
   TimeStep();
   t++;
   // check number of timesteps
   if (t==par.nit) {
     emit SimulationDone();
+  }
+}
   void Main::RestartSim(void) {
     stopSimulation();
     if ( QMessageBox::question(
 			       this,
 			       tr("Restart simulation?"),
 			       tr("Restart simulation.\n"
 				  "Are you sure?"),
 							   QMessageBox::Yes | QMessageBox::No, QMessageBox::NoButton ) == QMessageBox::Yes ) {
 void Main::RestartSim(void)
+{
       cerr << "Restarting simulation" << endl;
       //    extern Mesh mesh;
       mesh.Clear();
       Init();
 		Plot();
 		editor->FullRedraw();
+    }
     //startSimulation();
+  }
   stopSimulation();
   if ( QMessageBox::question(
 			     this,
 			     tr("Restart simulation?"),
 			     tr("Restart simulation.\n"
 				"Are you sure?"),
 			     QMessageBox::Yes | QMessageBox::No, QMessageBox::NoButton ) == QMessageBox::Yes ) {
     cerr << "Restarting simulation" << endl;
     //    extern Mesh mesh;
     mesh.Clear();
     Init();
     Plot();
     editor->FullRedraw();
+  }
   //startSimulation();
+}
 void Main::FitCanvasToWindow(void) {
 void Main::FitCanvasToWindow(void)
+{
   double scale_factor_x = (double)editor->width()/(double)canvas.width();
   double scale_factor_y = (double)editor->height()/(double)canvas.height();
   double scale_factor = scale_factor_x > scale_factor_y ? scale_factor_x : scale_factor_y;
   QMatrix m = editor->matrix();
-  #ifdef QDEBUG
 #ifdef QDEBUG
   qDebug() << "editor->width() = " << editor->width() << endl;
   qDebug() << "editor->height() = " << editor->height() << endl;
   qDebug() << "scale_factor = " << scale_factor << endl;
   qDebug() << "scale_factor_x = " << scale_factor_x << endl;
   qDebug() << "scale_factor_y = " << scale_factor_y << endl;
-  #endif
 #endif
   m.scale( scale_factor, scale_factor );
   editor->setMatrix( m );
   editor->show();
+}
   void Main::PauseIfRunning(void) {
     if (running) {
       timer->stop();
+    }
 void Main::PauseIfRunning(void)
+{
   if (running) {
     timer->stop();
+  }
+}
   void Main::ContIfRunning(void) {
     if (running) {
       timer->start( 0 );
+    }
 void Main::ContIfRunning(void)
+{
   if (running) {
     timer->start( 0 );
+  }
+}
 void Main::FitLeafToCanvas(void) {
 void Main::FitLeafToCanvas(void)
+{
   Vector ll,ur;
   mesh.BoundingBox(ll, ur);
   ll*=Cell::Magnification(); ur*=Cell::Magnification();
   // give the leaf some space
   Vector border = ((ur-ll)/5.);
   QRectF bb( ll.x - border.x, ll.y - border.y, ur.x-ll.x + 2*border.x, ur.y-ll.y + 2*border.y );
   // cerr << ur << ", " << ll << endl;
   editor->fitInView(bb, Qt::KeepAspectRatio);
+}
 void Main::CleanMesh(void) {
 	vector<double> clean_chem(Cell::NChem());
 	vector<double> clean_transporters(Cell::NChem());
 void Main::CleanMesh(void)
+{
   vector<double> clean_chem(Cell::NChem());
   vector<double> clean_transporters(Cell::NChem());
 	for (int i=0;i<Cell::NChem();i++) {
 		clean_chem[i]=par.initval[i];
 		clean_transporters[i]=0.;
+	}
 	mesh.CleanChemicals(clean_chem);
 	mesh.CleanTransporters(clean_transporters);
 	mesh.setTime(0);
 	Plot();
 	editor->FullRedraw();
   for (int i=0;i<Cell::NChem();i++) {
     clean_chem[i]=par.initval[i];
     clean_transporters[i]=0.;
+  }
   mesh.CleanChemicals(clean_chem);
   mesh.CleanTransporters(clean_transporters);
   mesh.setTime(0);
   Plot();
   editor->FullRedraw();
+}
 void Main::CleanMeshChemicals(void) {
 	vector<double> clean_chem(Cell::NChem());
 void Main::CleanMeshChemicals(void)
+{
   vector<double> clean_chem(Cell::NChem());
 	for (int i=0;i<Cell::NChem();i++) {
 		clean_chem[i]=par.initval[i];
+	}
 	mesh.CleanChemicals(clean_chem);
 	mesh.setTime(0);
 	Plot();
 	editor->FullRedraw();
   for (int i=0;i<Cell::NChem();i++) {
     clean_chem[i]=par.initval[i];
+  }
   mesh.CleanChemicals(clean_chem);
   mesh.setTime(0);
   Plot();
   editor->FullRedraw();
+}
 void Main::CleanMeshTransporters(void) {
 	vector<double> clean_transporters(Cell::NChem());
 	for (int i=0;i<Cell::NChem();i++) {
 		clean_transporters[i]=0.;
+	}
 	mesh.CleanTransporters(clean_transporters);
 	mesh.setTime(0);
 	Plot();
 	editor->FullRedraw();
 void Main::CleanMeshTransporters(void)
+{
   vector<double> clean_transporters(Cell::NChem());
   for (int i=0;i<Cell::NChem();i++) {
     clean_transporters[i]=0.;
+  }
   mesh.CleanTransporters(clean_transporters);
   mesh.setTime(0);
   Plot();
   editor->FullRedraw();
+}
 void Main::RandomizeMesh(void) {
 void Main::RandomizeMesh(void)
+{
   vector<double> max_chem(Cell::NChem());
   vector<double> max_transporters(Cell::NChem());
   for (int i=0;i<Cell::NChem();i++) {
     max_transporters[i]=0.;
     max_chem[i]=par.initval[i];
+  }
   // Amount of PIN1 at walls
   max_transporters[1] = 0.01;
   mesh.RandomizeChemicals(max_chem, max_transporters);
   Plot();
+}
 void Main::XMLReadSettings(xmlNode *settings) {
 void Main::XMLReadSettings(xmlNode *settings)
+{
   MainBase::XMLReadSettings(settings);
   view->setItemChecked(com_id, showcentersp);
   view->setItemChecked(mesh_id, showmeshp);
   view->setItemChecked(border_id, showbordercellp);
   view->setItemChecked(node_number_id, shownodenumbersp);
@@ @@ -1271,16 +1286,17 @@ void Main::XMLReadSettings(xmlNode *sett @@
   view->setItemChecked(movie_frames_id, movieframesp);
   view->setItemChecked(only_boundary_id, showboundaryonlyp);
   view->setItemChecked(fluxes_id, showfluxesp);
   view->setItemChecked(hide_cells_id, hidecellsp);
   options->setItemChecked(dyn_cells_id, dynamicscellsp);
   view->setItemChecked( cell_walls_id, showwallsp);
-	view->setItemChecked( apoplasts_id, showapoplastsp);
+  view->setItemChecked( apoplasts_id, showapoplastsp);
+}
 xmlNode *Main::XMLSettingsTree(void) {
 xmlNode *Main::XMLSettingsTree(void)
+{
   showcentersp = view->isItemChecked(com_id);
   showmeshp = view->isItemChecked(mesh_id);
   showbordercellp =  view->isItemChecked(border_id);
   shownodenumbersp =  view->isItemChecked(node_number_id);
   showcellnumbersp =  view->isItemChecked(cell_number_id);
@@ @@ -1288,14 +1304,13 @@ xmlNode *Main::XMLSettingsTree(void) { @@
   showcellstrainp = view->isItemChecked( cell_strain_id );
   movieframesp = view->isItemChecked(movie_frames_id);;
   showboundaryonlyp =  view->isItemChecked(only_boundary_id);
   showfluxesp = view->isItemChecked(fluxes_id);
   dynamicscellsp = options->isItemChecked(dyn_cells_id);
   showwallsp = view->isItemChecked( cell_walls_id);
-	showapoplastsp = view->isItemChecked( apoplasts_id);
+  showapoplastsp = view->isItemChecked( apoplasts_id);
   hidecellsp = view->isItemChecked( hide_cells_id);
   return MainBase::XMLSettingsTree();
+}
 /* finis */

src/canvas.h

➞

Show inline comments

@@ @@ -50,34 +50,34 @@ @@
 #endif
 #include <libxml/xpath.h>
 #include <libxml/xmlreader.h>
 #if defined(Q_OS_MAC)
-  #define PREFIX "cmd"
 #define PREFIX "cmd"
 #else
-  #define PREFIX "crtl"
 #define PREFIX "crtl"
 #endif
 class QFile;
 class QDir;
 class ModelCatalogue;
 class InfoBar;
 class FigureEditor : public QGraphicsView {
   Q_OBJECT
     friend class Main;
-    public:
  public:
   FigureEditor(QGraphicsScene&, Mesh&, QWidget* parent=0, const char* name=0, Qt::WFlags f=0);
   void clear();
   void Save(const char *fname, const char *format, int sizex=640, int sizey=480);
   void FullRedraw(void);
 protected:
+ protected:
   void mousePressEvent(QMouseEvent*);
   void mouseMoveEvent(QMouseEvent*);
   void mouseReleaseEvent(QMouseEvent*);
   void wheelEvent(QWheelEvent *event);
   void scaleView(qreal scaleFactor);
@@ @@ -93,23 +93,23 @@ protected: @@
   Mesh &mesh;
  private:
   //NodeItem* moving;
   SimItemBase *moving;
   QPointF moving_start;
   QGraphicsLineItem *intersection_line;
   bool rotation_mode;
   bool insert_mode;
   double rot_angle;
 };
 class Main : public Q3MainWindow, public MainBase {
   Q_OBJECT
 	friend class ModelCatalogue; // needs to populate menu item models
     public:
     friend class ModelCatalogue; // needs to populate menu item models
  public:
   Main(QGraphicsScene&, Mesh&, QWidget* parent=0, const char* name=0, Qt::WFlags f=0);
   ~Main();
   virtual bool ShowCentersP(void) {return view->isItemChecked(com_id);}
   virtual bool ShowMeshP(void) {return view->isItemChecked(mesh_id);}
   virtual bool ShowBorderCellsP(void) {return view->isItemChecked(border_id);}
   virtual bool PausedP(void) {return run->isItemChecked(paused_id);}
@@ @@ -117,24 +117,25 @@ class Main : public Q3MainWindow, public @@
   virtual bool ShowCellNumbersP(void) {return view->isItemChecked(cell_number_id);}
   virtual bool ShowCellAxesP(void) {return view->isItemChecked(cell_axes_id);}
   virtual bool ShowCellStrainP(void) {return view->isItemChecked(cell_strain_id);}
   virtual bool MovieFramesP(void) {return view->isItemChecked(movie_frames_id);}
   virtual bool ShowBoundaryOnlyP(void) {return view->isItemChecked(only_boundary_id);}
   virtual bool ShowWallsP(void) {return view->isItemChecked(cell_walls_id);}
-	virtual bool ShowApoplastsP(void) { return view->isItemChecked(apoplasts_id);}
+  virtual bool ShowApoplastsP(void) { return view->isItemChecked(apoplasts_id);}
   virtual bool ShowFluxesP(void) { return view->isItemChecked(fluxes_id); }
   virtual bool DynamicCellsP(void) { return options->isItemChecked(dyn_cells_id); }
   virtual bool RotationModeP(void) { return options->isItemChecked(rotation_mode_id); }
   virtual bool InsertModeP(void) { return options->isItemChecked(insert_mode_id); }
   virtual bool ShowToolTipsP(void) { return helpmenu->isItemChecked(tooltips_id); }
   virtual bool HideCellsP(void) { return view->isItemChecked(hide_cells_id); }
   void scale(double factor);
   virtual double getFluxArrowsize(void) {
   virtual double getFluxArrowsize(void)
+  {
     return flux_arrow_size;
+  }
   void FitCanvasToWindow();
   void FitLeafToCanvas(void);
   public slots:
@@ @@ -159,37 +160,39 @@ class Main : public Q3MainWindow, public @@
   void toggleHideCells(void);
   void print();
   void startSimulation(void);
   void stopSimulation(void);
   void RefreshInfoBar(void);
   void EnterRotationMode(void) {
   void EnterRotationMode(void)
+  {
     UserMessage("Rotation mode. Click mouse to exit.");
     if (editor) {
       editor->rot_angle = 0. ;
       // Exit rotation mode if mouse is clicked
       connect(editor, SIGNAL(MousePressed()), this, SLOT(ExitRotationMode()));
+    }
+  }
   void ExitRotationMode(void) {
   void ExitRotationMode(void)
+  {
     UserMessage("Exited rotation mode.",2000);
     options->setItemChecked(rotation_mode_id, false);
     if (editor)
       disconnect(editor, SIGNAL(MousePressed()), this, SLOT(ExitRotationMode()));
+  }
   virtual void UserMessage(QString message, int timeout=0);
   void Refresh(void) { Plot(); }
   void PauseIfRunning(void);
   void ContIfRunning(void);
   virtual void XMLReadSettings(xmlNode *settings);
   private slots:
   void aboutQt();
   void newView();
   void EditParameters();
   void readStateXML();
   int readStateXML(const char *filename, bool geometry = true, bool pars=true, bool simtime = true);
@@ @@ -206,33 +209,33 @@ class Main : public Q3MainWindow, public @@
   virtual void CutSAM() { MainBase::CutSAM(); Refresh();}
   void enlarge();
   void shrink();
   void zoomIn();
   void zoomOut();
   void CleanMesh();
 	void CleanMeshChemicals(void);
 	void CleanMeshTransporters(void);
   void CleanMeshChemicals(void);
   void CleanMeshTransporters(void);
   void RandomizeMesh();
  signals:
   void SimulationDone(void);
   void ParsChanged(void);
  protected:
   Mesh &mesh;
  private:
   NodeSet *node_set;
   FigureEditor *editor;
   Q3PopupMenu* options;
   Q3PopupMenu *view;
   Q3PopupMenu *run;
-	QMenu *modelmenu;
+  QMenu *modelmenu;
   Q3PopupMenu *helpmenu;
   QPrinter* printer;
   const QDir *working_dir;
   QString currentFile;
   //  toggle item states
@@ @@ -244,13 +247,13 @@ class Main : public Q3MainWindow, public @@
   int border_id; // view->Show border cells
   int paused_id; // run->Simulation paused
   int cell_axes_id; // view->Show cell axes
   int cell_strain_id; // view->Show cell strain
   int only_boundary_id; // view ->Show only leaf boundary
   int cell_walls_id; // view -> Show transporters
-	int apoplasts_id; // view -> Show apoplasts
+  int apoplasts_id; // view -> Show apoplasts
   int tooltips_id; // help -> Show Cell Info
   int hide_cells_id; // view->Hide Cells
   double flux_arrow_size;
   int movie_frames_id;
   int fluxes_id;
   int dyn_cells_id;
@@ @@ -259,13 +262,12 @@ class Main : public Q3MainWindow, public @@
   QTimer *timer;
   QFile *gifanim;
   bool running;
   virtual xmlNode *XMLSettingsTree(void);
   static const QString caption;
   static const QString caption_with_file;
 	InfoBar *infobar;
   InfoBar *infobar;
 };
+#endif
-#endif
+/* finis*/

src/cell.cpp

➞

Show inline comments

@@ @@ -37,1796 +37,1740 @@ 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(void) : CellBase()
+{
   m=0;
+}
 Cell::Cell(double x, double y, double z) : CellBase(x,y,z) {
 	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;
 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 Cell::operator=(const Cell &src)
+{
   CellBase::operator=(src);
   m=src.m;
   return *this;
+}
 //Cell(void) : CellBase() {}
 void Cell::DivideOverAxis(Vector axis) {
 	// Build a wall
 	// ->  find the position of the wall
 	// better look for intersection with a simple line intersection algorithm as below?
 	// this leads to some exceptions: e.g. dividing a horizontal rectangle.
 	// leaving it like this for the time being
 	if (dead) return;
 	Vector centroid=Centroid();
 	double prev_cross_z=(axis * (centroid - *(nodes.back()) ) ).z ;
 	ItList new_node_locations;
 	for (list<Node *>::iterator i=nodes.begin();
 		 i!=nodes.end();
 		 i++) {
 		// cross product to detect position of division
 		Vector cross = axis * (centroid - *(*i));
 		if (cross.z * prev_cross_z < 0 ) {
 			new_node_locations.push_back(i);
+		}
 		prev_cross_z=cross.z;
+	}
 	DivideWalls(new_node_locations, centroid, centroid+axis);
 void Cell::DivideOverAxis(Vector axis)
+{
   // Build a wall
   // ->  find the position of the wall
   // better look for intersection with a simple line intersection algorithm as below?
   // this leads to some exceptions: e.g. dividing a horizontal rectangle.
   // leaving it like this for the time being
   if (dead) return;
   Vector centroid=Centroid();
   double prev_cross_z=(axis * (centroid - *(nodes.back()) ) ).z ;
   ItList new_node_locations;
   for (list<Node *>::iterator i=nodes.begin();
        i!=nodes.end();
        i++) {
     // cross product to detect position of division
     Vector cross = axis * (centroid - *(*i));
     if (cross.z * prev_cross_z < 0 ) {
       new_node_locations.push_back(i);
+    }
     prev_cross_z=cross.z;
+  }
   DivideWalls(new_node_locations, centroid, centroid+axis);
+}
 double Cell::MeanArea(void) {
 	return m->MeanArea();
 double Cell::MeanArea(void)
+{
   return m->MeanArea();
+}
 void Cell::Apoptose(void) {
 	// First kill walls
         #ifdef QDEBUG
         qDebug() << "This is cell " << Index() << endl;
 	qDebug() << "Number of walls: " << walls.size() << endl;
 	#endif
 	for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
              #ifdef QDEBUG
 	     qDebug() << "Before apoptosis, wall " << (*w)->Index() << " says: c1 = "
 		      << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
              #endif
+	}
 	for (list<Wall *>::iterator w=walls.begin();
 		 w!=walls.end();
 		 w++) {
 		bool illegal_flag = false;
 		if ((*w)->c1 == (*w)->c2 )
 			illegal_flag=true;
 		if ((*w)->c1 == this) {
 			// invert wall?
 			(*w)->c1 = (*w)->c2;
 			(*w)->c2 = m->boundary_polygon;
 			Node *n1 = (*w)->n1;
 			(*w)->n1 = (*w)->n2;
 			(*w)->n2 = n1;
 		} else {
 			(*w)->c2 = m->boundary_polygon;
+		}
 		#ifdef QDEBUG
 		if (illegal_flag && (*w)->c1==(*w)->c2) {
 		  qDebug() << "I created an illegal wall." << endl;
+		}
 		#endif
 void Cell::Apoptose(void)
+{
   // First kill walls
 #ifdef QDEBUG
   qDebug() << "This is cell " << Index() << endl;
   qDebug() << "Number of walls: " << walls.size() << endl;
 #endif
   for (list<Wall *>::iterator w=walls.begin(); w!=walls.end(); w++) {
 #ifdef QDEBUG
     qDebug() << "Before apoptosis, wall " << (*w)->Index() << " says: c1 = "
 	     << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
 #endif
+  }
   for (list<Wall *>::iterator w=walls.begin();
        w!=walls.end();
        w++) {
     bool illegal_flag = false;
     if ((*w)->c1 == (*w)->c2 )
       illegal_flag=true;
     if ((*w)->c1 == this) {
 		if ( ((*w)->N1()->DeadP() || (*w)->N2()->DeadP()) ||
 			((*w)->C1() == (*w)->C2() ) ){
 			// kill wall
 		        #ifdef QDEBUG
 		        qDebug() << "Killing wall." << endl;
 			#endif
 			(*w)->Kill();
       // invert wall?
       (*w)->c1 = (*w)->c2;
       (*w)->c2 = m->boundary_polygon;
       Node *n1 = (*w)->n1;
       (*w)->n1 = (*w)->n2;
       (*w)->n2 = n1;
     } else {
       (*w)->c2 = m->boundary_polygon;
+    }
 #ifdef QDEBUG
     if (illegal_flag && (*w)->c1==(*w)->c2) {
       qDebug() << "I created an illegal wall." << endl;
+    }
 #endif
     if ( ((*w)->N1()->DeadP() || (*w)->N2()->DeadP()) ||
 	 ((*w)->C1() == (*w)->C2() ) ){
       // kill wall
 #ifdef QDEBUG
       qDebug() << "Killing wall." << endl;
 #endif
       (*w)->Kill();
 			#ifdef QDEBUG
 			if ((*w)) {
 			  qDebug() << "Wall " << (*w)->Index() << " says: c1 = "
 				   << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
+			}
 			#endif
 			(*w)=0;
 		} else {
 		        #ifdef QDEBUG
 		        qDebug() << "Not killing wall." << endl;
 			qDebug() << "Wall " << (*w)->Index() << " says: c1 = "
 				 << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
                         #endif
+		}
+	}
 	walls.remove(0);
 	// Unregister me from my nodes, and delete the node if it no longer belongs to any cells
 	list<Node *> superfluous_nodes;
 	for (list<Node *>::iterator n=nodes.begin();
 		 n!=nodes.end();
 		 n++) {
 		Node &no(*(*n));
 		// locate myself in the node's owner list
 		list<Neighbor>::iterator cellpos;
 		bool cell_found=false;
 		for (list<Neighbor>::iterator nb=no.owners.begin();
 			 nb!=no.owners.end();
 			 nb++) {
 			if (nb->cell == this) {
 				cellpos = nb;
 				cell_found = true;
 				break;
+			}
+		}
 		if (!cell_found) {
 			// I think this cannot happen; but if I am wrong, unpredictable things would happen. So throw an exception.
 			throw ("Cell not found in CellBase::Apoptose()\n\rPlease correct the code to handle this situation.");
+		}
 		Neighbor tmp = *cellpos;
 		no.owners.erase(cellpos);
 		// if node has no owners left, or only has a connection to special cell -1 (outside world), mark it as dead.
 		if (no.owners.size()==0 || (no.owners.size()==1 && no.owners.front().cell->BoundaryPolP()) ) {
 			no.MarkDead();
 		} else {
 			// register node with outside world
 			if (find_if( no.owners.begin(), no.owners.end(),
 				     bind2nd ( mem_fun_ref(&Neighbor::CellEquals), m->boundary_polygon->Index() ) ) == no.owners.end() ) {
 				tmp.cell = m->boundary_polygon;
 				no.owners.push_back(tmp);
+			}
+		}
+	}
 	// mark cell as dead
 	MarkDead();
 #ifdef QDEBUG
       if ((*w)) {
 	qDebug() << "Wall " << (*w)->Index() << " says: c1 = "
 		 << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
+      }
 #endif
       (*w)=0;
     } else {
 #ifdef QDEBUG
       qDebug() << "Not killing wall." << endl;
       qDebug() << "Wall " << (*w)->Index() << " says: c1 = "
 	       << (*w)->c1->Index() << ", c2 = " << (*w)->c2->Index() << endl;
 #endif
+    }
+  }
   walls.remove(0);
   // Unregister me from my nodes, and delete the node if it no longer belongs to any cells
   list<Node *> superfluous_nodes;
   for (list<Node *>::iterator n=nodes.begin();
        n!=nodes.end();
        n++) {
     Node &no(*(*n));
     // locate myself in the node's owner list
     list<Neighbor>::iterator cellpos;
     bool cell_found=false;
     for (list<Neighbor>::iterator nb=no.owners.begin();
 	 nb!=no.owners.end();
 	 nb++) {
       if (nb->cell == this) {
 	cellpos = nb;
 	cell_found = true;
 	break;
+      }
+    }
     if (!cell_found) {
       // I think this cannot happen; but if I am wrong, unpredictable things would happen. So throw an exception.
       throw ("Cell not found in CellBase::Apoptose()\n\rPlease correct the code to handle this situation.");
+    }
     Neighbor tmp = *cellpos;
     no.owners.erase(cellpos);
     // if node has no owners left, or only has a connection to special cell -1 (outside world), mark it as dead.
     if (no.owners.size()==0 || (no.owners.size()==1 && no.owners.front().cell->BoundaryPolP()) ) {
       no.MarkDead();
     } else {
       // register node with outside world
       if (find_if( no.owners.begin(), no.owners.end(),
 		   bind2nd ( mem_fun_ref(&Neighbor::CellEquals), m->boundary_polygon->Index() ) ) == no.owners.end() ) {
 	tmp.cell = m->boundary_polygon;
 	no.owners.push_back(tmp);
+      }
+    }
+  }
   // mark cell as dead
   MarkDead();
+}
 void Cell::ConstructConnections(void) {
     // Tie up the nodes of this cell, assuming they are correctly ordered
     //cerr << "Constructing connections of cell " << index << endl;
     for (list<Node *>::iterator i=nodes.begin();
 		 i!=nodes.end();
 		 i++) {
 		//cerr << "Connecting node " << *i << endl;
 		//cerr << "Node " << *i << endl << " = " << *(*i) << endl;
 		// 1. Tidy up existing connections (which are part of this cell)
 		if ((*i)->owners.size()>0) {
 			list<Neighbor>::iterator neighb_with_this_cell=
 			// remove myself from the neighbor list of the node
 			find_if((*i)->owners.begin(),
 					(*i)->owners.end(),
 				bind2nd(mem_fun_ref( &Neighbor::CellEquals ),this->Index() )  );
 			if (neighb_with_this_cell!=(*i)->owners.end())
 				(*i)->owners.erase(neighb_with_this_cell);
+		}
 		Node *previous;
 		if (i!=nodes.begin()) {
 			list<Node *>::iterator previous_iterator=i;
 			previous_iterator--;
 			previous=*previous_iterator;
 		} else {
 			previous=nodes.back();
+		}
 		Node *next;
 		list<Node *>::iterator next_iterator=i;
 		next_iterator++;
 		if (next_iterator==nodes.end()) {
 			next=nodes.front();
 		} else {
 			next=*next_iterator;
+		}
 		//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;
 		// }
 void Cell::ConstructConnections(void)
+{
   // Tie up the nodes of this cell, assuming they are correctly ordered
   //cerr << "Constructing connections of cell " << index << endl;
   for (list<Node *>::iterator i=nodes.begin();
        i!=nodes.end();
        i++) {
     //cerr << "Connecting node " << *i << endl;
     //cerr << "Node " << *i << endl << " = " << *(*i) << endl;
     // 1. Tidy up existing connections (which are part of this cell)
     if ((*i)->owners.size()>0) {
       list<Neighbor>::iterator neighb_with_this_cell=
 	// remove myself from the neighbor list of the node
 	find_if((*i)->owners.begin(),
 		(*i)->owners.end(),
 		bind2nd(mem_fun_ref( &Neighbor::CellEquals ),this->Index() )  );
       if (neighb_with_this_cell!=(*i)->owners.end())
 	(*i)->owners.erase(neighb_with_this_cell);
+    }
     Node *previous;
     if (i!=nodes.begin()) {
       list<Node *>::iterator previous_iterator=i;
       previous_iterator--;
       previous=*previous_iterator;
     } else {
       previous=nodes.back();
+    }
     Node *next;
     list<Node *>::iterator next_iterator=i;
     next_iterator++;
     if (next_iterator==nodes.end()) {
       next=nodes.front();
     } else {
       next=*next_iterator;
+    }
     (*i)->owners.push_back( Neighbor( this, previous, next ) );
+  }
+}
 bool Cell::DivideOverGivenLine(const Vector v1, const Vector v2, bool fix_cellwall, NodeSet *node_set )
+{
   if (dead) return false;
   // check each edge for intersection with the line
   ItList new_node_locations;
 #ifdef QDEBUG
   qDebug() << "Cell " << Index() << " is doing DivideOverGivenLine" << endl;
 #endif
   for (list<Node *>::iterator i=nodes.begin();
        i!=nodes.end();
        i++) {
     Vector v3 = *(*i);
     list<Node *>::iterator nb=i;
     nb++;
     if (nb == nodes.end()) {
       nb = nodes.begin();
+    }
     Vector v4 = *(*nb);
     double denominator =
       (v4.y - v3.y)*(v2.x - v1.x) - (v4.x - v3.x)*(v2.y - v1.y);
     double ua =
       ((v4.x - v3.x)*(v1.y - v3.y) - (v4.y - v3.y)*(v1.x -v3.x))/denominator;
     double ub =
       ((v2.x - v1.x)*(v1.y-v3.y) - (v2.y- v1.y)*(v1.x - v3.x))/denominator;
 /*! \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;
 	#ifdef QDEBUG
 	qDebug() << "Cell " << Index() << " is doing DivideOverGivenLine" << endl;
 	#endif
 	for (list<Node *>::iterator i=nodes.begin();
 		 i!=nodes.end();
 		 i++) {
 		Vector v3 = *(*i);
 		list<Node *>::iterator nb=i;
 		nb++;
 		if (nb == nodes.end()) {
 			nb = nodes.begin();
+		}
 		Vector v4 = *(*nb);
 		double denominator =
 		(v4.y - v3.y)*(v2.x - v1.x) - (v4.x - v3.x)*(v2.y - v1.y);
 		double ua =
 		((v4.x - v3.x)*(v1.y - v3.y) - (v4.y - v3.y)*(v1.x -v3.x))/denominator;
 		double ub =
 		((v2.x - v1.x)*(v1.y-v3.y) - (v2.y- v1.y)*(v1.x - v3.x))/denominator;
 		//cerr << "Edge " << *i << " to " << *nb << ": ua = " << ua << ", ub = " << ub << ":  ";
 		// this construction with "TINY" should simulate open/closed interval <0,1]
 		if ( ( TINY < ua && ua < 1.+TINY ) && ( TINY < ub && ub < 1.+TINY ) ) {
 			// yes, intersection detected. Push the location to the list of iterators
 			new_node_locations.push_back(nb);
+		}
+	}
         #ifdef QDEBUG
 	if (new_node_locations.size()<2) {
 	  qDebug() << "Line does not intersect with two edges of Cell " << Index() << endl;
 	  qDebug() << "new_node_locations.size() = " << new_node_locations.size() << endl;
 	  return false;
+	}
 	ItList::iterator i = new_node_locations.begin();
 	list< Node *>::iterator j;
 	qDebug() << "-------------------------------" << endl;
 	qDebug() << "Location of new nodes: " << (**i)->Index() << " and ";
     //cerr << "Edge " << *i << " to " << *nb << ": ua = " << ua << ", ub = " << ub << ":  ";
     // this construction with "TINY" should simulate open/closed interval <0,1]
     if ( ( TINY < ua && ua < 1.+TINY ) && ( TINY < ub && ub < 1.+TINY ) ) {
       // yes, intersection detected. Push the location to the list of iterators
       new_node_locations.push_back(nb);
+    }
+}
 #ifdef QDEBUG
   if (new_node_locations.size()<2) {
     qDebug() << "Line does not intersect with two edges of Cell " << Index() << endl;
     qDebug() << "new_node_locations.size() = " << new_node_locations.size() << endl;
     return false;
+  }
 	++i;
 	j = *i;
 	if (j==nodes.begin()) j=nodes.end(); j--;
 	qDebug() << (*j)->Index() << endl;
 	qDebug() << "-------------------------------" << endl;
 	if ( **new_node_locations.begin() == *j ) {
 	  qDebug() << "Rejecting proposed division (cutting off zero area)." << endl;
 		return false;
+	}
 	#endif
 ItList::iterator i = new_node_locations.begin();
 list< Node *>::iterator j;
 qDebug() << "-------------------------------" << endl;
 qDebug() << "Location of new nodes: " << (**i)->Index() << " and ";
 ++i;
 j = *i;
 if (j==nodes.begin()) j=nodes.end(); j--;
 	DivideWalls(new_node_locations, v1, v2, fix_cellwall, node_set);
 	return true;
 qDebug() << (*j)->Index() << endl;
 qDebug() << "-------------------------------" << endl;
 if ( **new_node_locations.begin() == *j ) {
   qDebug() << "Rejecting proposed division (cutting off zero area)." << endl;
   return false;
+ }
 #endif
 DivideWalls(new_node_locations, v1, v2, fix_cellwall, node_set);
 return true;
+}
 // Core division procedure
 void Cell::DivideWalls(ItList new_node_locations, const Vector from, const Vector to, bool fix_cellwall, NodeSet *node_set) {
 	if (dead) return;
 	bool boundary_touched_flag=false;
 	// Step 0: keep some data about the parent before dividing
 	ParentInfo parent_info;
 	parent_info.polarization = ReduceCellAndWalls<Vector>( PINdir );
 	parent_info.polarization.Normalise();
 	parent_info.PINmembrane = SumTransporters(1);
 	parent_info.PINendosome = Chemical(1);
 	//cerr << "Parent polarization before division: " << parent_info.polarization << endl;
 	// Step 1: create a daughter cell
 	Cell *daughter=m->AddCell(new Cell());
 	// Step 2: Copy the basics of parent cell to daughter
 	for (int i=0;i<NChem();i++) {
 		daughter->chem[i]=chem[i];
+	}
 	daughter->cell_type = cell_type;
 	for (int i=0;i<NChem();i++) {
 		daughter->new_chem[i]=new_chem[i];
+	}
 	daughter->boundary=boundary;
 	daughter->m=m;
 	daughter->target_area=target_area/2.;
 	target_area/=2;
 	daughter->cellvec=cellvec;
 	// Division currently only works for convex cells: i.e. if the division line
 	// intersects the cells at two points only.
 	if (new_node_locations.size()!=2) {
 		// Note: if you would add the possibility of dividing non-convex
 		// cells, remember to update the code below. There are some
 		// fixed-size arrays over there!
 		cerr << "Warning in Cell::Division: division of non-convex cells not fully implemented" << endl;
 		// Reject the daughter cell and decrement the amount of cells
 		// again. We can do this here because it is the last cell added.
 		// Never, ever try to fully erase a cell elsewhere, because we
 		// make heavy use of cell indices in this project; if you erase a
 		// Cell somewhere in the middle of Mesh::Cells the indices will
 		// get totally messed up...! (e.g. the indices used in Nodes::cells)
 		#ifdef QDEBUG
 		qDebug() << "new_node_locations.size() = " << new_node_locations.size() <<endl;
 		qDebug() << "daughter->index = " << daughter->index << endl;
 		qDebug() << "cells.size() = " << m->cells.size() << endl;
 		#endif
 void Cell::DivideWalls(ItList new_node_locations, const Vector from, const Vector to, bool fix_cellwall, NodeSet *node_set)
+{
   if (dead) return;
   bool boundary_touched_flag=false;
   // Step 0: keep some data about the parent before dividing
   ParentInfo parent_info;
   parent_info.polarization = ReduceCellAndWalls<Vector>( PINdir );
   parent_info.polarization.Normalise();
   parent_info.PINmembrane = SumTransporters(1);
   parent_info.PINendosome = Chemical(1);
   //cerr << "Parent polarization before division: " << parent_info.polarization << endl;
   // Step 1: create a daughter cell
   Cell *daughter=m->AddCell(new Cell());
   // Step 2: Copy the basics of parent cell to daughter
   for (int i=0;i<NChem();i++) {
     daughter->chem[i]=chem[i];
+  }
   daughter->cell_type = cell_type;
   for (int i=0;i<NChem();i++) {
     daughter->new_chem[i]=new_chem[i];
+  }
   daughter->boundary=boundary;
   daughter->m=m;
   daughter->target_area=target_area/2.;
   target_area/=2;
   daughter->cellvec=cellvec;
   // Division currently only works for convex cells: i.e. if the division line
   // intersects the cells at two points only.
   if (new_node_locations.size()!=2) {
     // Note: if you would add the possibility of dividing non-convex
     // cells, remember to update the code below. There are some
     // fixed-size arrays over there!
     cerr << "Warning in Cell::Division: division of non-convex cells not fully implemented" << endl;
     // Reject the daughter cell and decrement the amount of cells
     // again. We can do this here because it is the last cell added.
     // Never, ever try to fully erase a cell elsewhere, because we
     // make heavy use of cell indices in this project; if you erase a
     // Cell somewhere in the middle of Mesh::Cells the indices will
     // get totally messed up...! (e.g. the indices used in Nodes::cells)
 #ifdef QDEBUG
     qDebug() << "new_node_locations.size() = " << new_node_locations.size() <<endl;
     qDebug() << "daughter->index = " << daughter->index << endl;
     qDebug() << "cells.size() = " << m->cells.size() << endl;
 #endif
 		m->cells.pop_back();
 		Cell::NCells()--;
 		m->shuffled_cells.pop_back();
 		return;
+	}
 	// We can be sure we only need two positions here because divisions
 	// of non-convex cells are rejected above.
 	Vector new_node[2];
 	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;
     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;
+    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 << endl ;
 		} 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;
     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 << endl ;
     } 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] );
+	}
 	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
+			}
 			// if new node is inserted into the boundary
 			// it will be part of the boundary, too
       // 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
+      }
       // 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;
 			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.
 	// 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) {
                                 #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();
 	  m->boundary_polygon->nodes.insert(((ins_pos--)!=m->boundary_polygon->nodes.begin()?ins_pos:(--m->boundary_polygon->nodes.end())), new_node_ind[i]);
 				// 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
 	  // .. 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;
 			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 ) );
       // 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
 #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);
+	}
+      }
 			// 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
 			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);
+			  }
+			}
       // 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()) {
                         #ifdef QDEBUG
 			qDebug() << "The edge owners list has: " << edge_owners.size() << " elements" << endl;
 			#endif
 	  // 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();
 			// 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();
 	  // 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;
 			// (can we have more than one neighboring cell here??)
 			if (c!=owners.end()) {
 				neighbor_cell = c->cell;
 				if (!c->cell->BoundaryPolP()) {
       // 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 ) );
 					// 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()) {
 #ifdef QDEBUG
 	qDebug() << "Whoops, wall element not found...!" << endl;
 	qDebug() << "Cell ID: " << neighbor_cell->Index() << endl;
 	qDebug() << "My cell ID: " << Index() << endl;
 #endif
       } 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;
 			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()) {
 			        #ifdef QDEBUG
 			        qDebug() << "Whoops, wall element not found...!" << endl;
 			        qDebug() << "Cell ID: " << neighbor_cell->Index() << endl;
 				qDebug() << "My cell ID: " << Index() << endl;
                                 #endif
 			} 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];
+					}
 					// 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()) {
 			        #ifdef QDEBUG
 			  qDebug() << "not found" << endl;
                                 #endif
 				abort();
+			}
 			(*i)->owners.erase(neighb_with_this_cell);
 			daughter->nodes.push_back( *i );
 			i++;
 			if (i==nodes.end())
 				i=nodes.begin();
 		};
 	  // 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];
+	  }
 	  // 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;
+	  }
+	}
 	// 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();
 		};
+	}
+      }
+    }
   }  // 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()) {
 #ifdef QDEBUG
 	qDebug() << "not found" << endl;
 #endif
 	abort();
+      }
       (*i)->owners.erase(neighb_with_this_cell);
       daughter->nodes.push_back( *i );
 	// 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] );
+	}
       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 {
 			node->fixed = 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 );
+		}
+	}
   // 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 {
       node->fixed = 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]);
+		}
+	}
 	//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);
 	daughter->div_counter=(++div_counter);
   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]);
+    }
+  }
   //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);
   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;
+    }
   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++) {
 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++) {
     for (list<Neighbor>::const_iterator n=(*i)->owners.begin();
 	 n!=(*i)->owners.end();
 	 n++) {
       if (n->getCell()!=this) {
 	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());
+      }
+    }
+  }
 		for (list<Neighbor>::const_iterator n=(*i)->owners.begin();
 			 n!=(*i)->owners.end();
 			 n++) {
 			if (n->getCell()!=this) {
 				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;
 	} else {
 		Move ( -1*movement);
+	}
 	return dh;
   // 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;
   } 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);
 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;
 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/
 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++)
+      {
     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;
 			if ( ( TINY < ua && ua < 1.-TINY ) && ( TINY < ub && ub < 1.-TINY ) ) {
 				//cerr << "ua = " << ua << ", ub = " << ub << endl;
 				return true;
+			}
+		}
+    }
     return false;
 	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;
 	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;
 			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;
       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++)
 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;
 		if ( ( TINY < ua && ua < 1.-TINY ) && ( TINY < ub && ub < 1.-TINY ) ) {
 			return true;
+		}
       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;
       if ( ( TINY < ua && ua < 1.-TINY ) && ( TINY < ub && ub < 1.-TINY ) ) {
 	return true;
+      }
+    }
 	return false;
   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) {
   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;
 	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 ));
+      }
+    }
     // One Wall for each neighbor, so we should be able to correctly construct neighbor lists here.
     if (duplicates[0]==this) {
       AddWall(  new Wall(*nb,*i,duplicates[0],duplicates[1]) );
       if (!duplicates[1]->BoundaryPolP()) {
 		// 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) {
 			AddWall(  new Wall(*nb,*i,duplicates[0],duplicates[1]) );
 			if (!duplicates[1]->BoundaryPolP()) {
 				neighbors.push_back(duplicates[1]);
+			}
 		} else {
 			AddWall ( new Wall(*nb,*i,duplicates[1],duplicates[0]) );
 			if (!duplicates[0]->BoundaryPolP()) {
 				neighbors.push_back(duplicates[0]);
+			}
+		}
+	}
 	neighbors.push_back(duplicates[1]);
+      }
     } else {
       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 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] );
 			#ifdef QDEBUG
 			if ((*i)->c1!=this) {
 			  qDebug() << "Warning, bad cells boundary: " << (*i)->c1->Index() << ", " << index << endl;
+			}
 			#endif
 			flux[c] += phi;
+		}
+	}
 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] );
 #ifdef QDEBUG
       if ((*i)->c1!=this) {
 	qDebug() << "Warning, bad cells boundary: " << (*i)->c1->Index() << ", " << index << endl;
+      }
 #endif
       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()) {
 	        #ifdef QDEBUG
 	  qDebug() << "Cell " << index << " not drawn, because dead." << endl;
 		#endif
 		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);
 	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::Draw(QGraphicsScene *c, QString tooltip)
+{
   // Draw the cell on a QCanvas object
   if (DeadP()) {
 #ifdef QDEBUG
     qDebug() << "Cell " << index << " not drawn, because dead." << endl;
 #endif
     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);
   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
   // 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);
   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;
   for (list<Node *>::const_iterator n=nodes.begin();
        n!=nodes.end();
        n++) {
     Node *i=*n;
 		NodeItem *item = new NodeItem ( &(*i), c );
 		item->setColor();
 		item->setZValue(5);
 		item->show();
 		item ->setPos(((offset[0]+i->x)*factor),
 					  ((offset[1]+i->y)*factor) );
+	}
     NodeItem *item = new NodeItem ( &(*i), c );
     item->setColor();
     item->setZValue(5);
     item->show();
     item ->setPos(((offset[0]+i->x)*factor),
 		  ((offset[1]+i->y)*factor) );
+  }
+}
 void Cell::DrawIndex(QGraphicsScene *c) const {
 	DrawText( c, QString("%1").arg(index));
   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->show();
 	ctext ->setPos(((offset[0]+centroid.x)*factor),
 				   ((offset[1]+centroid.y)*factor) );
   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->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 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;
   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();
   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 {
   c = NULL; // assignment merely to obviate compilation warning
-	MyWarning::warning("Sorry, Cell::DrawStrain temporarily not implemented.");
+  MyWarning::warning("Sorry, Cell::DrawStrain temporarily not implemented.");
+}
 void Cell::DrawFluxes(QGraphicsScene *c, double arrowsize)  {
 	// get the mean flux through this cell
 	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::DrawFluxes(QGraphicsScene *c, double arrowsize)
+{
   // get the mean flux through this cell
   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 ) );
   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()) );
   DrawText(c, QString("%1").arg(walls.size()) );
+}
 #endif
+#endif // QTGRAPHICS !
 /*! \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
+	}
   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
         #ifdef QDEBUG
 	if (w->c1 == w->c2 ){
 	  qDebug() << "Wall between identical cells: " << w->c1->Index()<< endl;
+	}
 	#endif
 void Cell::AddWall( Wall *w )
+{
   // if necessary, we could try later inserting it at the correct position
 #ifdef QDEBUG
   if (w->c1 == w->c2 ){
     qDebug() << "Wall between identical cells: " << w->c1->Index()<< endl;
+  }
 #endif
 	// 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);
+	}
   // 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 )
 				 );
 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)
+{
 void Cell::EmitValues(double t) {
 	//  cerr << "Attempting to emit " << t << ", " << chem[0] << ", " << chem[1] << endl;
 	emit ChemMonValue(t, chem);
   //  cerr << "Attempting to emit " << t << ", " << chem[0] << ", " << chem[1] << endl;
   emit ChemMonValue(t, chem);
+}
 /* finis */

src/cell.h

➞

Show inline comments

@@ @@ -42,164 +42,156 @@ @@
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #include <QMouseEvent>
 class Cell : public CellBase
+{
 	Q_OBJECT
 	friend class Mesh;
 	friend class FigureEditor;
   Q_OBJECT
     friend class Mesh;
   friend class FigureEditor;
  public:
   Cell(double x, double y, double z = 0.);
   Cell(void);
   Cell(const Cell &src);
   Cell operator=(const Cell &src);
   bool Cmp(Cell*) const;
   bool Eq(Cell*) const;
   inline bool IndexEquals(int i) { return i == index; }
   static void SetMagnification(const double &magn) {
     factor=magn;
+  }
   static Vector Offset(void) {
     Vector offs;
     offs.x=offset[0];
     offs.y=offset[1];
     return offs;
+  }
 public:
 	Cell(double x, double y, double z = 0.);
 	Cell(void);
 	Cell(const Cell &src);
 	Cell operator=(const Cell &src);
 	bool Cmp(Cell*) const;
 	bool Eq(Cell*) const;
   static void Translate(const double &tx,const double &ty) {
     offset[0]+=tx;
     offset[1]+=ty;
+  }
   inline static double Factor(void) {
     return factor;
+  }
   static void setOffset(double ox, double oy) {
     offset[0]=ox;
     offset[1]=oy;
+  }
   static double Magnification(void) {
     return factor;
+  }
   static double Scale(const double scale) {
     factor*=scale;
     return factor;
+  }
   void DivideOverAxis(Vector axis); // divide cell over axis
   // divide over the line (if line and cell intersect)
   bool DivideOverGivenLine(const Vector v1, const Vector v2, bool wall_fixed = false, NodeSet *node_set = 0);
   void Divide(void) { // Divide cell over short axis
     Vector long_axis;
     Length(&long_axis);
     DivideOverAxis(long_axis.Perp2D());
+  }
 	inline bool IndexEquals(int i) { return i == index; }
 	static void SetMagnification(const double &magn) {
 		factor=magn;
+    }
     static Vector Offset(void) {
 		Vector offs;
 		offs.x=offset[0];
 		offs.y=offset[1];
 		return offs;
+    }
 	static void Translate(const double &tx,const double &ty) {
 		offset[0]+=tx;
 		offset[1]+=ty;
+    }
     inline static double Factor(void) {
 		return factor;
+    }
     static void setOffset(double ox, double oy) {
 		offset[0]=ox;
 		offset[1]=oy;
+    }
     static double Magnification(void) {
 		return factor;
+    }
     static double Scale(const double scale) {
 		factor*=scale;
 		return factor;
+    }
     void DivideOverAxis(Vector axis); // divide cell over axis
     bool DivideOverGivenLine(const Vector v1, const Vector v2, bool wall_fixed = false, NodeSet *node_set = 0); // divide over the line (if line and cell intersect)
     void Divide(void) { // Divide cell over short axis
 		Vector long_axis;
 		Length(&long_axis);
 		DivideOverAxis(long_axis.Perp2D());
+    }
 	//void CheckForGFDrivenDivision(void);
     inline int NNodes(void) const { return nodes.size(); }
     void Move(Vector T);
     void Move(double dx, double dy, double dz=0) {
 		Move( Vector (dx, dy, dz) );
+    }
 	double Displace(double dx, double dy, double dh);
     void Displace(void);
     double Energy(void) const;
     bool SelfIntersect(void);
     bool MoveSelfIntersectsP(Node *nid, Vector new_pos);
     bool IntersectsWithLineP(const Vector v1, const Vector v2);
   //void CheckForGFDrivenDivision(void);
   inline int NNodes(void) const { return nodes.size(); }
   void Move(Vector T);
   void Move(double dx, double dy, double dz=0) {
     Move( Vector (dx, dy, dz) );
+  }
   double Displace(double dx, double dy, double dh);
   void Displace(void);
   double Energy(void) const;
   bool SelfIntersect(void);
   bool MoveSelfIntersectsP(Node *nid, Vector new_pos);
   bool IntersectsWithLineP(const Vector v1, const Vector v2);
   void XMLAdd(xmlNodePtr cells_node) const;
   void ConstructWalls(void);
   void Flux(double *flux, double *D);
   void OnClick(QMouseEvent *e);
   inline Mesh& getMesh(void) const { return *m; }
   double MeanArea(void);
   void Apoptose(void); // Cell kills itself
   list<Wall *>::iterator RemoveWall( Wall *w );
   void AddWall( Wall *w );
   void Draw(QGraphicsScene *c, QString tooltip = QString::Null());
 	void XMLAdd(xmlNodePtr cells_node) const;
 	void ConstructWalls(void);
 	void Flux(double *flux, double *D);
 	/*! \brief Method called if a cell is clicked.
 	 Define this in the end-user code (e.g. meinhardt.cpp).
 	 */
     void OnClick(QMouseEvent *e);
     inline Mesh& getMesh(void) const { return *m; }
 	double MeanArea(void);
 	void Apoptose(void); // Cell kills itself
 	list<Wall *>::iterator RemoveWall( Wall *w );
     void AddWall( Wall *w );
   // Draw a text in the cell's center
   void DrawText(QGraphicsScene *c, const QString &text) const;
   void DrawIndex(QGraphicsScene *c) const;
   void DrawCenter(QGraphicsScene *c) const;
   void DrawNodes(QGraphicsScene *c) const;
   void DrawAxis(QGraphicsScene *c) const;
   void DrawStrain(QGraphicsScene *c) const;
   void DrawFluxes(QGraphicsScene *c, double arrowsize = 1.);
   void DrawWalls(QGraphicsScene *c) const;
   void DrawValence(QGraphicsScene *c) const;
   void EmitValues(double t);
     void Draw(QGraphicsScene *c, QString tooltip = QString::Null());
 	// Draw a text in the cell's center
     void DrawText(QGraphicsScene *c, const QString &text) const;
     void DrawIndex(QGraphicsScene *c) const;
     void DrawCenter(QGraphicsScene *c) const;
     void DrawNodes(QGraphicsScene *c) const;
 	void DrawAxis(QGraphicsScene *c) const;
     void DrawStrain(QGraphicsScene *c) const;
     void DrawFluxes(QGraphicsScene *c, double arrowsize = 1.);
     void DrawWalls(QGraphicsScene *c) const;
     void DrawValence(QGraphicsScene *c) const;
     void EmitValues(double t);
 signals:
     void ChemMonValue(double t, double *x);
 protected:
 	void XMLAddCore(xmlNodePtr xmlcell) const;
     int XMLRead(xmlNode *cur);
 	void DivideWalls(ItList new_node_locations, const Vector from, const Vector to, bool wall_fixed = false, NodeSet *node_set = 0);
  signals:
   void ChemMonValue(double t, double *x);
  protected:
   void XMLAddCore(xmlNodePtr xmlcell) const;
   int XMLRead(xmlNode *cur);
   void DivideWalls(ItList new_node_locations, const Vector from, const Vector to, bool wall_fixed = false, NodeSet *node_set = 0);
 private:
+ private:
     static QPen *cell_outline_pen;
 	static double offset[3];
     static double factor;
 	Mesh *m;
 	void ConstructConnections(void);
 	void SetWallLengths(void);
   static QPen *cell_outline_pen;
   static double offset[3];
   static double factor;
   Mesh *m;
   void ConstructConnections(void);
   void SetWallLengths(void);
 };
 // Boundarypolygon is a special cell; will not increase ncells
 //  and will not be part of Mesh::cells
 class BoundaryPolygon : public Cell {
 public:
 	BoundaryPolygon(void) : Cell() {
 		NCells()--;
 		index=-1;
+	}
     BoundaryPolygon(double x,double y,double z=0) : Cell (x,y,z) {
 		NCells()--;
 		index=-1;
+    }
 	BoundaryPolygon &operator=(Cell &src) {
 		Cell::operator=(src);
 		index=-1;
 		return *this;
+	}
 	virtual void Draw(QGraphicsScene *c, QString tooltip = QString::Null());
 	virtual void XMLAdd(xmlNodePtr parent_node) const;
 	virtual bool BoundaryPolP(void) const { return true; }
  public:
  BoundaryPolygon(void) : Cell() {
     NCells()--;
     index=-1;
+  }
  BoundaryPolygon(double x,double y,double z=0) : Cell (x,y,z) {
     NCells()--;
     index=-1;
+  }
   BoundaryPolygon &operator=(Cell &src) {
     Cell::operator=(src);
     index=-1;
     return *this;
+  }
   virtual void Draw(QGraphicsScene *c, QString tooltip = QString::Null());
   virtual void XMLAdd(xmlNodePtr parent_node) const;
   virtual bool BoundaryPolP(void) const { return true; }
 };
+#endif
-#endif
+/* finis */

src/cellbase.cpp

➞

Show inline comments

@@ @@ -58,601 +58,593 @@ const char* CellBase::boundary_type_name @@
 CellsStaticDatamembers *CellBase::static_data_members = new CellsStaticDatamembers();
 #else
 CellsStaticDatamembers *CellBase::static_data_members = 0;
 #endif
 CellBase::CellBase(QObject *parent) :
 QObject(parent),
 Vector()
   QObject(parent),
   Vector()
+{
 	chem=new double[NChem()];
 	for (int i=0;i<NChem();i++) {
 		chem[i]=0.;
+	}
 	new_chem=new double[NChem()];
 	for (int i=0;i<NChem();i++) {
 		new_chem[i]=0.;
+	}
 	boundary=None;
 	index=(NCells()++);
 	area=0.;
 	target_area=1;
 	target_length=0; //par.target_length;
 	lambda_celllength = 0; //par.lambda_celllength;
 	intgrl_xx=0.; intgrl_xy=0.; intgrl_yy=0.;
 	intgrl_x=0.; intgrl_y=0.;
 	source = false;
 	source_conc = 0.;
 	source_chem = 0;
 	at_boundary=false;
 	fixed = false;
 	pin_fixed = false;
 	stiffness = 0;
 	marked = false;
 	dead = false;
 	div_counter=0;
 	cell_type = 0;
 	flag_for_divide = false;
 	division_axis = 0;
   chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     chem[i]=0.;
+  }
   new_chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     new_chem[i]=0.;
+  }
   boundary=None;
   index=(NCells()++);
   area=0.;
   target_area=1;
   target_length=0; //par.target_length;
   lambda_celllength = 0; //par.lambda_celllength;
   intgrl_xx=0.; intgrl_xy=0.; intgrl_yy=0.;
   intgrl_x=0.; intgrl_y=0.;
   source = false;
   source_conc = 0.;
   source_chem = 0;
   at_boundary=false;
   fixed = false;
   pin_fixed = false;
   stiffness = 0;
   marked = false;
   dead = false;
   div_counter=0;
   cell_type = 0;
   flag_for_divide = false;
   division_axis = 0;
+}
 CellBase::CellBase(double x,double y,double z) : QObject(), Vector(x,y,z)
+{
 #ifndef VLEAFPLUGIN
 	if (static_data_members == 0) {
 		static_data_members = new CellsStaticDatamembers();
+	}
   if (static_data_members == 0) {
     static_data_members = new CellsStaticDatamembers();
+  }
 #endif
 	chem=new double[NChem()];
 	for (int i=0;i<NChem();i++) {
 		chem[i]=0.;
+	}
 	new_chem=new double[NChem()];
 	for (int i=0;i<NChem();i++) {
 		new_chem[i]=0.;
+	}
 	boundary=None;
 	area=0.;
 	target_area=1;
 	target_length=0; //par.target_length;
 	lambda_celllength=0; // par.lambda_celllength;
 	index=(NCells()++);
 	intgrl_xx=0.; intgrl_xy=0.; intgrl_yy=0.;
 	intgrl_x=0.; intgrl_y=0.;
 	source = false;
 	fixed = false;
 	at_boundary=false;
 	pin_fixed = false;
 	stiffness = 0;
 	marked=false;
 	dead  = false;
 	div_counter = 0;
 	cell_type = 0;
 	flag_for_divide = false;
 	division_axis = 0;
   chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     chem[i]=0.;
+  }
   new_chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     new_chem[i]=0.;
+  }
   boundary=None;
   area=0.;
   target_area=1;
   target_length=0; //par.target_length;
   lambda_celllength=0; // par.lambda_celllength;
   index=(NCells()++);
   intgrl_xx=0.; intgrl_xy=0.; intgrl_yy=0.;
   intgrl_x=0.; intgrl_y=0.;
   source = false;
   fixed = false;
   at_boundary=false;
   pin_fixed = false;
   stiffness = 0;
   marked=false;
   dead  = false;
   div_counter = 0;
   cell_type = 0;
   flag_for_divide = false;
   division_axis = 0;
+}
 CellBase::CellBase(const CellBase &src) :  Vector(src), QObject()
+{
 	chem=new double[NChem()];
 	for (int i=0;i<NChem();i++) {
 		chem[i]=src.chem[i];
+	}
 	new_chem=new double[NChem()];
 	for (int i=0;i<NChem();i++) {
 		new_chem[i]=src.new_chem[i];
+	}
 	boundary=src.boundary;
 	area=src.area;
 	target_length=src.target_length;
 	lambda_celllength=src.lambda_celllength;
 	intgrl_xx=src.intgrl_xx; intgrl_xy=src.intgrl_xy; intgrl_yy=src.intgrl_yy;
 	intgrl_x=src.intgrl_x; intgrl_y=src.intgrl_y;
 	target_area=src.target_area;
 	index=src.index;
 	nodes=src.nodes;
 	neighbors=src.neighbors;
 	walls=src.walls;
 	source = src.source;
 	fixed = src.fixed;
 	source_conc = src.source_conc;
 	source_chem = src.source_chem;
 	cellvec = src.cellvec;
 	at_boundary=src.at_boundary;
 	pin_fixed = src.pin_fixed;
 	stiffness = src.stiffness;
 	marked = src.marked;
 	dead = src.dead;
 	cell_type = src.cell_type;
 	div_counter = src.div_counter;
 	flag_for_divide = src.flag_for_divide;
 	division_axis = src.division_axis;
   chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     chem[i]=src.chem[i];
+  }
   new_chem=new double[NChem()];
   for (int i=0;i<NChem();i++) {
     new_chem[i]=src.new_chem[i];
+  }
   boundary=src.boundary;
   area=src.area;
   target_length=src.target_length;
   lambda_celllength=src.lambda_celllength;
   intgrl_xx=src.intgrl_xx; intgrl_xy=src.intgrl_xy; intgrl_yy=src.intgrl_yy;
   intgrl_x=src.intgrl_x; intgrl_y=src.intgrl_y;
   target_area=src.target_area;
   index=src.index;
   nodes=src.nodes;
   neighbors=src.neighbors;
   walls=src.walls;
   source = src.source;
   fixed = src.fixed;
   source_conc = src.source_conc;
   source_chem = src.source_chem;
   cellvec = src.cellvec;
   at_boundary=src.at_boundary;
   pin_fixed = src.pin_fixed;
   stiffness = src.stiffness;
   marked = src.marked;
   dead = src.dead;
   cell_type = src.cell_type;
   div_counter = src.div_counter;
   flag_for_divide = src.flag_for_divide;
   division_axis = src.division_axis;
+}
 CellBase CellBase::operator=(const CellBase &src) {
 	Vector::operator=(src);
 CellBase CellBase::operator=(const CellBase &src)
+{
   Vector::operator=(src);
 	for (int i=0;i<NChem();i++) {
 		chem[i]=src.chem[i];
+	}
 	for (int i=0;i<NChem();i++) {
 		new_chem[i]=src.chem[i];
+	}
 	boundary=src.boundary;
 	area=src.area;
 	intgrl_xx=src.intgrl_xx; intgrl_xy=src.intgrl_xy; intgrl_yy=src.intgrl_yy;
 	intgrl_x=src.intgrl_x; intgrl_y=src.intgrl_y;
 	target_area=src.target_area;
 	target_length=src.target_length;
 	lambda_celllength=src.lambda_celllength;
 	index=src.index;
   for (int i=0;i<NChem();i++) {
     chem[i]=src.chem[i];
+  }
   for (int i=0;i<NChem();i++) {
     new_chem[i]=src.chem[i];
+  }
   boundary=src.boundary;
   area=src.area;
   intgrl_xx=src.intgrl_xx; intgrl_xy=src.intgrl_xy; intgrl_yy=src.intgrl_yy;
   intgrl_x=src.intgrl_x; intgrl_y=src.intgrl_y;
   target_area=src.target_area;
   target_length=src.target_length;
   lambda_celllength=src.lambda_celllength;
 	nodes=src.nodes;
 	neighbors=src.neighbors;
 	walls=src.walls;
 	source = src.source;
 	fixed = src.fixed;
 	source_conc = src.source_conc;
 	source_chem = src.source_chem;
 	cellvec = src.cellvec;
 	at_boundary=src.at_boundary;
 	pin_fixed = src.pin_fixed;
 	stiffness = src.stiffness;
 	marked = src.marked;
 	dead = src.dead;
 	cell_type = src.cell_type;
 	div_counter = src.div_counter;
 	flag_for_divide = src.flag_for_divide;
 	division_axis = src.division_axis;
 	return *this;
   index=src.index;
   nodes=src.nodes;
   neighbors=src.neighbors;
   walls=src.walls;
   source = src.source;
   fixed = src.fixed;
   source_conc = src.source_conc;
   source_chem = src.source_chem;
   cellvec = src.cellvec;
   at_boundary=src.at_boundary;
   pin_fixed = src.pin_fixed;
   stiffness = src.stiffness;
   marked = src.marked;
   dead = src.dead;
   cell_type = src.cell_type;
   div_counter = src.div_counter;
   flag_for_divide = src.flag_for_divide;
   division_axis = src.division_axis;
   return *this;
+}
 void CellBase::SetChemical(int c, double conc) {
 	if (c>=NChem()) {
 		stringstream error;
 		error << "SetChemical: value c = " << c << " is out of range\n";
 		throw error.str().c_str();
+	}
 	chem[c]=conc;
 void CellBase::SetChemical(int c, double conc)
+{
   if (c>=NChem()) {
     stringstream error;
     error << "SetChemical: value c = " << c << " is out of range\n";
     throw error.str().c_str();
+  }
   chem[c]=conc;
+}
 void CellBase::SetTransporters(int ch, double conc) {
 	if (ch>=NChem()) {
 		stringstream error;
 		error << "SetChemical: value ch = " << ch << " is out of range\n";
 		throw error.str().c_str();
+	}
 	for (list<Wall *>::iterator w=walls.begin();
 		 w!=walls.end();
 		 w++) {
 		(*w)->setTransporter(this, ch, conc);
+	}
 void CellBase::SetTransporters(int ch, double conc)
+{
   if (ch>=NChem()) {
     stringstream error;
     error << "SetChemical: value ch = " << ch << " is out of range\n";
     throw error.str().c_str();
+  }
   for (list<Wall *>::iterator w=walls.begin();
        w!=walls.end();
        w++) {
     (*w)->setTransporter(this, ch, conc);
+  }
+}
 ostream &CellBase::print(ostream &os) const {
 	os << "[ index = " << index << " {" << x << ", " << y << ", " << z << "}: {";
 	for (int i=0;i<NChem()-1;i++) {
 		os << chem[i] << ", ";
+	}
 	os << chem[NChem()-1] << " } ]";
 	os << endl << "Nodelist = { " << endl;
 	for (list<Node *>::const_iterator i =  nodes.begin(); i!=nodes.end(); i++) {
 		os << (*i)->Index() << "( " << *i << ") ";
+	}
 	os << " } ";
 	for (list<Wall *>::const_iterator i =  walls.begin(); i!=walls.end(); i++) {
 		(*i)->print(os);
 		os << ", ";
+	}
 	os << endl;
 	os << " [ area = " << area << " ]";
 	os << " [ walls = ";
 	for (list<Wall *>::const_iterator i= walls.begin();
 		 i!=walls.end();
 		 i++) {
 		os << (*i)->n1->Index() << " -> " << (*i)->n2->Index() << ", " <<  (*i)->c1->Index() << " | " << (*i)->c2->Index() << ", ";
+	}
 	os << " ] ";
 	os << "div_counter = " << div_counter << endl;
 	os << "cell_type = " << cell_type << endl;
 	os << endl;
 	return os;
 ostream &CellBase::print(ostream &os) const
+{
   os << "[ index = " << index << " {" << x << ", " << y << ", " << z << "}: {";
   for (int i=0;i<NChem()-1;i++) {
     os << chem[i] << ", ";
+  }
   os << chem[NChem()-1] << " } ]";
   os << endl << "Nodelist = { " << endl;
   for (list<Node *>::const_iterator i =  nodes.begin(); i!=nodes.end(); i++) {
     os << (*i)->Index() << "( " << *i << ") ";
+  }
   os << " } ";
   for (list<Wall *>::const_iterator i =  walls.begin(); i!=walls.end(); i++) {
     (*i)->print(os);
     os << ", ";
+  }
   os << endl;
   os << " [ area = " << area << " ]";
   os << " [ walls = ";
   for (list<Wall *>::const_iterator i= walls.begin();
        i!=walls.end();
        i++) {
     os << (*i)->n1->Index() << " -> " << (*i)->n2->Index() << ", " <<  (*i)->c1->Index() << " | " << (*i)->c2->Index() << ", ";
+  }
   os << " ] ";
   os << "div_counter = " << div_counter << endl;
   os << "cell_type = " << cell_type << endl;
   os << endl;
   return os;
+}
 ostream &operator<<(ostream &os, const CellBase &c) {
 	c.print(os);
 	return os;
 ostream &operator<<(ostream &os, const CellBase &c)
+{
   c.print(os);
   return os;
+}
 double CellBase::CalcArea(void) const {
 	double loc_area=0.;
 	for (list<Node *>::const_iterator i=nodes.begin();
 		 i!=(nodes.end());
 		 i++) {
 		list<Node *>::const_iterator i_plus_1=i; i_plus_1++;
 		if (i_plus_1==nodes.end())
 			i_plus_1=nodes.begin();
 		loc_area+= (*i)->x * (*i_plus_1)->y;
 		loc_area-= (*i_plus_1)->x * (*i)->y;
+	}
 double CellBase::CalcArea(void) const
+{
   double loc_area=0.;
   for (list<Node *>::const_iterator i=nodes.begin();
        i!=(nodes.end());
        i++) {
 	// http://technology.niagarac.on.ca/courses/ctec1335/docs/arrays2.pdf
 	//return loc_area/2.0;
 	return fabs(loc_area)/2.0;
     list<Node *>::const_iterator i_plus_1=i; i_plus_1++;
     if (i_plus_1==nodes.end())
       i_plus_1=nodes.begin();
     loc_area+= (*i)->x * (*i_plus_1)->y;
     loc_area-= (*i_plus_1)->x * (*i)->y;
+  }
   // http://technology.niagarac.on.ca/courses/ctec1335/docs/arrays2.pdf
   return fabs(loc_area)/2.0;
+}
 Vector CellBase::Centroid(void) const {
 	double area=0.;
 	double integral_x_dxdy=0.,integral_y_dxdy=0.;
 	for (list<Node *>::const_iterator i=nodes.begin();
 		 i!=(nodes.end());
 		 i++) {
 		list<Node *>::const_iterator i_plus_1=i; i_plus_1++;
 		if (i_plus_1==nodes.end())
 			i_plus_1=nodes.begin();
 		area+= (*i)->x * (*i_plus_1)->y;
 		area-= (*i_plus_1)->x * (*i)->y;
 		integral_x_dxdy+=
 			((*i_plus_1)->x+(*i)->x)*
 			((*i)->x*(*i_plus_1)->y-
 			 (*i_plus_1)->x*(*i)->y);
 		integral_y_dxdy+=
 			((*i_plus_1)->y+(*i)->y)*
 			((*i)->x*(*i_plus_1)->y-
 			 (*i_plus_1)->x*(*i)->y);
+	}
 	//area/=2.0;
 	area = fabs(area)/2.0;
 	integral_x_dxdy/=6.;
 	integral_y_dxdy/=6.;
 	Vector centroid(integral_x_dxdy,integral_y_dxdy,0);
 	centroid/=area;
 	return centroid;
 Vector CellBase::Centroid(void) const
+{
   double area=0.;
   double integral_x_dxdy=0.,integral_y_dxdy=0.;
   for (list<Node *>::const_iterator i=nodes.begin();
        i!=(nodes.end());
        i++) {
     list<Node *>::const_iterator i_plus_1=i; i_plus_1++;
     if (i_plus_1==nodes.end())
       i_plus_1=nodes.begin();
     area+= (*i)->x * (*i_plus_1)->y;
     area-= (*i_plus_1)->x * (*i)->y;
     integral_x_dxdy+=
       ((*i_plus_1)->x+(*i)->x)*
       ((*i)->x*(*i_plus_1)->y-
        (*i_plus_1)->x*(*i)->y);
     integral_y_dxdy+=
       ((*i_plus_1)->y+(*i)->y)*
       ((*i)->x*(*i_plus_1)->y-
        (*i_plus_1)->x*(*i)->y);
+  }
   area = fabs(area)/2.0;
   integral_x_dxdy/=6.;
   integral_y_dxdy/=6.;
   Vector centroid(integral_x_dxdy,integral_y_dxdy,0);
   centroid/=area;
   return centroid;
+}
 void CellBase::SetIntegrals(void) const {
 	// Set the initial values for the integrals over x^2,
 	// xy, yy, x, and y
 	// these values will be updated after each move of the CellBase wall
 	intgrl_xx=0.; intgrl_xy=0.; intgrl_yy=0.;
 	intgrl_x=0.; intgrl_y=0.;
 	area=0.;
 	list<Node *>::const_iterator nb;
 	list<Node *>::const_iterator i=nodes.begin();
 	for (;
 		 i!=(nodes.end());
 		 i++) {
 		nb = i; nb++; if (nb==nodes.end()) nb=nodes.begin();
 		area+=(*i)->x*(*nb)->y;
 		area-=(*nb)->x*(*i)->y;
 		intgrl_xx+=
 			((*i)->x*(*i)->x+
 			 (*nb)->x*(*i)->x+
 			 (*nb)->x*(*nb)->x ) *
 			((*i)->x*(*nb)->y-
 			 (*nb)->x*(*i)->y);
 		intgrl_xy+=
 			((*nb)->x*(*i)->y-
 			 (*i)->x*(*nb)->y)*
 			((*i)->x*(2*(*i)->y+(*nb)->y)+
 			 (*nb)->x*((*i)->y+2*(*nb)->y));
 		intgrl_yy+=
 			((*i)->x*(*nb)->y-
 			 (*nb)->x*(*i)->y)*
 			((*i)->y*(*i)->y+
 			 (*nb)->y*(*i)->y+
 			 (*nb)->y*(*nb)->y );
 		intgrl_x+=
 			((*nb)->x+(*i)->x)*
 			((*i)->x*(*nb)->y-
 			 (*nb)->x*(*i)->y);
 		intgrl_y+=
 			((*nb)->y+(*i)->y)*
 			((*i)->x*(*nb)->y-
 			 (*nb)->x*(*i)->y);
+	}
 void CellBase::SetIntegrals(void) const
+{
   // Set the initial values for the integrals over x^2,
   // xy, yy, x, and y
   // these values will be updated after each move of the CellBase wall
   intgrl_xx=0.; intgrl_xy=0.; intgrl_yy=0.;
   intgrl_x=0.; intgrl_y=0.;
   area=0.;
   list<Node *>::const_iterator nb;
   list<Node *>::const_iterator i=nodes.begin();
   for (;
        i!=(nodes.end());
        i++) {
     nb = i; nb++; if (nb==nodes.end()) nb=nodes.begin();
 	area = fabs(area)/2.0;
     area+=(*i)->x*(*nb)->y;
     area-=(*nb)->x*(*i)->y;
     intgrl_xx+=
       ((*i)->x*(*i)->x+
        (*nb)->x*(*i)->x+
        (*nb)->x*(*nb)->x ) *
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
     intgrl_xy+=
       ((*nb)->x*(*i)->y-
        (*i)->x*(*nb)->y)*
       ((*i)->x*(2*(*i)->y+(*nb)->y)+
        (*nb)->x*((*i)->y+2*(*nb)->y));
     intgrl_yy+=
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y)*
       ((*i)->y*(*i)->y+
        (*nb)->y*(*i)->y+
        (*nb)->y*(*nb)->y );
     intgrl_x+=
       ((*nb)->x+(*i)->x)*
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
     intgrl_y+=
       ((*nb)->y+(*i)->y)*
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
+  }
   area = fabs(area)/2.0;
+}
 double CellBase::Length(Vector *long_axis, double *width)  const {
 	// Calculate length and axes of CellBase
 	// Calculate inertia tensor
 	// see file inertiatensor.nb for explanation of this method
 	if (!lambda_celllength) {
 		// Without length constraint we do not keep track of the cells'
 		// moments of inertia. So we must calculate them here.
 		SetIntegrals();
+	}
 	double intrx=intgrl_x/6.;
 	double intry=intgrl_y/6.;
 	double ixx=(intgrl_xx/12.)-(intrx*intrx)/area;
 	double ixy=(intgrl_xy/24.)+(intrx*intry)/area;
 	double iyy=(intgrl_yy/12.)-(intry*intry)/area;
 	double rhs1=(ixx+iyy)/2., rhs2=sqrt( (ixx-iyy)*(ixx-iyy)+4*ixy*ixy )/2.;
 	double lambda_b=rhs1+rhs2;
 	// see: http://scienceworld.wolfram.com/physics/MomentofInertiaEllipse.html
 	//    cerr << "n = " << n << "\n";
 	if (long_axis) {
 		*long_axis = Vector(-ixy, lambda_b - ixx, 0);
 		//   cerr << "ixx = " << ixx << ", ixy = " << ixy << ", iyy = " << iyy << ", area = " << area << endl;
+	}
 	if (width) {
 		*width = 4*sqrt((rhs1-rhs2)/area);
+	}
 	return 4*sqrt(lambda_b/area);
 double CellBase::Length(Vector *long_axis, double *width)  const
+{
   // Calculate length and axes of CellBase
   // Calculate inertia tensor
   // see file inertiatensor.nb for explanation of this method
   if (!lambda_celllength) {
     // Without length constraint we do not keep track of the cells'
     // moments of inertia. So we must calculate them here.
     SetIntegrals();
+  }
   double intrx=intgrl_x/6.;
   double intry=intgrl_y/6.;
   double ixx=(intgrl_xx/12.)-(intrx*intrx)/area;
   double ixy=(intgrl_xy/24.)+(intrx*intry)/area;
   double iyy=(intgrl_yy/12.)-(intry*intry)/area;
   double rhs1=(ixx+iyy)/2., rhs2=sqrt( (ixx-iyy)*(ixx-iyy)+4*ixy*ixy )/2.;
   double lambda_b=rhs1+rhs2;
   // see: http://scienceworld.wolfram.com/physics/MomentofInertiaEllipse.html
   //    cerr << "n = " << n << "\n";
   if (long_axis) {
     *long_axis = Vector(-ixy, lambda_b - ixx, 0);
     //   cerr << "ixx = " << ixx << ", ixy = " << ixy << ", iyy = " << iyy << ", area = " << area << endl;
+  }
   if (width) {
     *width = 4*sqrt((rhs1-rhs2)/area);
+  }
   return 4*sqrt(lambda_b/area);
+}
 double CellBase::CalcLength(Vector *long_axis, double *width)  const {
 	// Calculate length and axes of CellBase, without touching cells raw moments
 	// Calculate inertia tensor
 	// see file inertiatensor.nb for explanation of this method
 	double my_intgrl_xx=0., my_intgrl_xy=0., my_intgrl_yy=0.;
 	double my_intgrl_x=0., my_intgrl_y=0., my_area=0.;
 	my_area=0.;
 	list<Node *>::const_iterator nb;
 	list<Node *>::const_iterator i=nodes.begin();
 	for (;
 		 i!=(nodes.end());
 		 i++) {
 		nb = i; nb++; if (nb==nodes.end()) nb=nodes.begin();
 		my_area+=(*i)->x*(*nb)->y;
 		my_area-=(*nb)->x*(*i)->y;
 		my_intgrl_xx+=
 			((*i)->x*(*i)->x+
 			 (*nb)->x*(*i)->x+
 			 (*nb)->x*(*nb)->x ) *
 			((*i)->x*(*nb)->y-
 			 (*nb)->x*(*i)->y);
 		my_intgrl_xy+=
 			((*nb)->x*(*i)->y-
 			 (*i)->x*(*nb)->y)*
 			((*i)->x*(2*(*i)->y+(*nb)->y)+
 			 (*nb)->x*((*i)->y+2*(*nb)->y));
 		my_intgrl_yy+=
 			((*i)->x*(*nb)->y-
 			 (*nb)->x*(*i)->y)*
 			((*i)->y*(*i)->y+
 			 (*nb)->y*(*i)->y+
 			 (*nb)->y*(*nb)->y );
 		my_intgrl_x+=
 			((*nb)->x+(*i)->x)*
 			((*i)->x*(*nb)->y-
 			 (*nb)->x*(*i)->y);
 		my_intgrl_y+=
 			((*nb)->y+(*i)->y)*
 			((*i)->x*(*nb)->y-
 			 (*nb)->x*(*i)->y);
+	}
 	//my_area/=2.0;
 	my_area = fabs(my_area)/2.0;
 	double intrx=my_intgrl_x/6.;
 	double intry=my_intgrl_y/6.;
 	double ixx=(my_intgrl_xx/12.)-(intrx*intrx)/my_area;
 	double ixy=(my_intgrl_xy/24.)+(intrx*intry)/my_area;
 	double iyy=(my_intgrl_yy/12.)-(intry*intry)/my_area;
 	double rhs1=(ixx+iyy)/2., rhs2=sqrt( (ixx-iyy)*(ixx-iyy)+4*ixy*ixy )/2.;
 	double lambda_b=rhs1+rhs2;
 	// see: http://scienceworld.wolfram.com/physics/MomentofInertiaEllipse.html
 	//    cerr << "n = " << n << "\n";
 	if (long_axis) {
 		*long_axis = Vector(-ixy, lambda_b - ixx, 0);
 		//   cerr << "ixx = " << ixx << ", ixy = " << ixy << ", iyy = " << iyy << ", my_area = " << my_area << endl;
+	}
 	if (width) {
 		*width = 4*sqrt((rhs1-rhs2)/my_area);
+	}
 	return 4*sqrt(lambda_b/my_area);
 double CellBase::CalcLength(Vector *long_axis, double *width)  const
+{
   // Calculate length and axes of CellBase, without touching cells raw moments
   // Calculate inertia tensor
   // see file inertiatensor.nb for explanation of this method
   double my_intgrl_xx=0., my_intgrl_xy=0., my_intgrl_yy=0.;
   double my_intgrl_x=0., my_intgrl_y=0., my_area=0.;
   my_area=0.;
   list<Node *>::const_iterator nb;
   list<Node *>::const_iterator i=nodes.begin();
   for (;
        i!=(nodes.end());
        i++) {
     nb = i; nb++; if (nb==nodes.end()) nb=nodes.begin();
     my_area+=(*i)->x*(*nb)->y;
     my_area-=(*nb)->x*(*i)->y;
     my_intgrl_xx+=
       ((*i)->x*(*i)->x+
        (*nb)->x*(*i)->x+
        (*nb)->x*(*nb)->x ) *
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
     my_intgrl_xy+=
       ((*nb)->x*(*i)->y-
        (*i)->x*(*nb)->y)*
       ((*i)->x*(2*(*i)->y+(*nb)->y)+
        (*nb)->x*((*i)->y+2*(*nb)->y));
     my_intgrl_yy+=
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y)*
       ((*i)->y*(*i)->y+
        (*nb)->y*(*i)->y+
        (*nb)->y*(*nb)->y );
     my_intgrl_x+=
       ((*nb)->x+(*i)->x)*
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
     my_intgrl_y+=
       ((*nb)->y+(*i)->y)*
       ((*i)->x*(*nb)->y-
        (*nb)->x*(*i)->y);
+  }
   //my_area/=2.0;
   my_area = fabs(my_area)/2.0;
   double intrx=my_intgrl_x/6.;
   double intry=my_intgrl_y/6.;
   double ixx=(my_intgrl_xx/12.)-(intrx*intrx)/my_area;
   double ixy=(my_intgrl_xy/24.)+(intrx*intry)/my_area;
   double iyy=(my_intgrl_yy/12.)-(intry*intry)/my_area;
   double rhs1=(ixx+iyy)/2., rhs2=sqrt( (ixx-iyy)*(ixx-iyy)+4*ixy*ixy )/2.;
   double lambda_b=rhs1+rhs2;
   // see: http://scienceworld.wolfram.com/physics/MomentofInertiaEllipse.html
   //    cerr << "n = " << n << "\n";
   if (long_axis) {
     *long_axis = Vector(-ixy, lambda_b - ixx, 0);
     //   cerr << "ixx = " << ixx << ", ixy = " << ixy << ", iyy = " << iyy << ", my_area = " << my_area << endl;
+  }
   if (width) {
     *width = 4*sqrt((rhs1-rhs2)/my_area);
+  }
   return 4*sqrt(lambda_b/my_area);
+}
 void CellBase::ConstructNeighborList(void)
+{
 void CellBase::ConstructNeighborList(void) {
 	neighbors.clear();
 	for (//list<Wall *>::const_reverse_iterator wit=walls.rbegin();
 		 list<Wall *>::const_iterator wit=walls.begin();
 		 // somehow the reverse_iterator returns by walls needs to be casted to const to let this work.
 		 // it seems to me it is a bug in the STL implementation...
   neighbors.clear();
   for (//list<Wall *>::const_reverse_iterator wit=walls.rbegin();
        list<Wall *>::const_iterator wit=walls.begin();
        // somehow the reverse_iterator returns by walls needs to be casted to const to let this work.
        // it seems to me it is a bug in the STL implementation...
        wit!=walls.end();
        wit++) {
     if ((*wit)->C1() != this) {
       neighbors.push_back((*wit)->C1());
     } else {
       neighbors.push_back((*wit)->C2());
+    }
+  }
 		 wit!=walls.end();
 		 wit++) {
 		if ((*wit)->C1() != this) {
 			neighbors.push_back((*wit)->C1());
 		} else {
 			neighbors.push_back((*wit)->C2());
+		}
+	}
 	// remove all boundary_polygons from the list
 	list <CellBase *>::iterator e=neighbors.begin();
 	at_boundary=false;
 	do {
 		// Code crashes here after cutting off part of the leaf. I can't find the problem.
 		// Leaving the "Illegal" walls in the simulation helps. (c1=-1 && c2=-1)
 		// Work-around: define leaf primordium. Save to XML. Restart. Read XML file.
 		// Sorry about this; I hope to solve this annoying issue later. RM :-).
 		// All cells in neighbors seem to be okay (I might be messing some part of the memory elsewhere
 		// during the cutting operation?).
 		e = find_if(neighbors.begin(),neighbors.end(),mem_fun(&CellBase::BoundaryPolP));
 		if (e!=neighbors.end()) {
 			e=neighbors.erase(e);
 			at_boundary=true;
 		} else {
 			break;
+		}
   // remove all boundary_polygons from the list
   list <CellBase *>::iterator e=neighbors.begin();
   at_boundary=false;
   do {
     // Code crashes here after cutting off part of the leaf. I can't find the problem.
     // Leaving the "Illegal" walls in the simulation helps. (c1=-1 && c2=-1)
     // Work-around: define leaf primordium. Save to XML. Restart. Read XML file.
     // Sorry about this; I hope to solve this annoying issue later. RM :-).
     // All cells in neighbors seem to be okay (I might be messing some part of the memory elsewhere
     // during the cutting operation?).
     e = find_if(neighbors.begin(),neighbors.end(),mem_fun(&CellBase::BoundaryPolP));
     if (e!=neighbors.end()) {
       e=neighbors.erase(e);
       at_boundary=true;
     } else {
       break;
+    }
   } while(1);
+}
 	// Save the cell to a stream so we can reconstruct its state later
 	void CellBase::Dump(ostream &os) const {
 		os << index << " " << nodes.size() << endl;
 		Vector::Dump(os);
 		os << endl;
 		for (list<Node *>::const_iterator i=nodes.begin();i!=nodes.end();i++) {
 			os << *i << " ";
+		}
 		os << endl;
 		os << index << " " << neighbors.size() << endl;
 		for (list<CellBase *>::const_iterator i=neighbors.begin();i!=neighbors.end();i++) {
 			os << *i << " ";
+		}
 		os << endl;
 		os << walls.size() << endl;
 		/*for (list<Wall *>::const_iterator i=walls.begin();i!=walls.end(); i++) {
 			(*i)->Dump(os);
 		}*/
 		os << endl;
 		os << NChem() << " ";
 		for (int i=0;i<NChem();i++) {
 			os << chem[i] << " ";
+		}
 		os << endl;
 		os << NChem() << " ";
 		for (int i=0;i<NChem();i++) {
 			os << new_chem[i] << " ";
+		}
 		os << endl;
 		os << boundary << " " << area << " " << target_area << " " << target_length << " " << fixed << " " << intgrl_xx << " " << intgrl_xy << " " << intgrl_yy << " " << intgrl_x << " " << intgrl_y << " " << source << " ";
 		cellvec.Dump(os);
 		os << " " << source_conc << " " << source_chem;
 		os << endl;
+	}
 	void CellBase::UnfixNodes(void) {
 		for (list<Node *>::const_iterator i=nodes.begin();
 			 i!=nodes.end();
 			 i++) {
 			(*i)->Unfix();
+		}
+	}
 	void CellBase::FixNodes(void) {
 		for (list<Node *>::const_iterator i=nodes.begin();
 			 i!=nodes.end();
 			 i++) {
 			(*i)->Fix();
+		}
+	}
 	// returns true if cell is at border
 	bool CellBase::AtBoundaryP(void) const {
 		return at_boundary;
+	}
 // Save the cell to a stream so we can reconstruct its state later
 void CellBase::Dump(ostream &os) const
+{
   os << index << " " << nodes.size() << endl;
   Vector::Dump(os);
   os << endl;
   for (list<Node *>::const_iterator i=nodes.begin();i!=nodes.end();i++) {
     os << *i << " ";
+  }
   os << endl;
   os << index << " " << neighbors.size() << endl;
   for (list<CellBase *>::const_iterator i=neighbors.begin();i!=neighbors.end();i++) {
     os << *i << " ";
+  }
   os << endl << walls.size() << endl << endl;
   os << NChem() << " ";
   for (int i=0;i<NChem();i++) {
     os << chem[i] << " ";
+  }
   os << endl;
   os << NChem() << " ";
   for (int i=0;i<NChem();i++) {
     os << new_chem[i] << " ";
+  }
   os << endl;
   os << boundary << " " << area << " " << target_area << " " << target_length
      << " " << fixed << " " << intgrl_xx << " " << intgrl_xy << " " << intgrl_yy
      << " " << intgrl_x << " " << intgrl_y << " " << source << " ";
   cellvec.Dump(os);
   os << " " << source_conc << " " << source_chem;
   os << endl;
+}
 QString CellBase::printednodelist(void) {
 	QString info_string = "Nodelist = { ";
 	for (list<Node *>::const_iterator i =  nodes.begin(); i!=nodes.end(); i++) {
 		info_string += QString("%1 ").arg((*i)->Index());
+	}
 	info_string += " } ";
 	return info_string;
 void CellBase::UnfixNodes(void)
+{
   for (list<Node *>::const_iterator i=nodes.begin();
        i!=nodes.end();
        i++) {
     (*i)->Unfix();
+  }
+}
 void CellBase::FixNodes(void)
+{
   for (list<Node *>::const_iterator i=nodes.begin();
        i!=nodes.end();
        i++) {
     (*i)->Fix();
+  }
+}
 // returns true if cell is at border
 bool CellBase::AtBoundaryP(void) const
+{
   return at_boundary;
+}
 QString CellBase::printednodelist(void)
+{
   QString info_string = "Nodelist = { ";
   for (list<Node *>::const_iterator i =  nodes.begin(); i!=nodes.end(); i++) {
     info_string += QString("%1 ").arg((*i)->Index());
+  }
   info_string += " } ";
   return info_string;
+}
 /* finis*/

src/cellbase.h

➞

Show inline comments

@@ @@ -44,443 +44,422 @@ using namespace std; @@
 class Mesh;
 class Node;
 class CellBase;
 class NodeSet;
 struct ParentInfo {
 	Vector polarization;
 	double PINmembrane;
 	double PINendosome;
   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.;
                 #ifdef QDEBUG
 		qDebug() << "Constructor of CellsStaticDatamembers" << endl;
 		#endif
+	}
 	~CellsStaticDatamembers() {
                 #ifdef QDEBUG
 	        qDebug() << "Oops! Desctructor of CellsStaticDatamembers called" << endl;
                 #endif
+	}
 	int ncells;
 	int nchem;
 	double base_area;
  public:
   CellsStaticDatamembers(void) {
     ncells = 0;
     nchem = 0;
     base_area = 0.;
 #ifdef QDEBUG
     qDebug() << "Constructor of CellsStaticDatamembers" << endl;
 #endif
+  }
   ~CellsStaticDatamembers() {
 #ifdef QDEBUG
     qDebug() << "Oops! Desctructor of CellsStaticDatamembers called" << endl;
 #endif
+  }
   int ncells;
   int nchem;
   double base_area;
 };
 class CellBase :  public QObject, public Vector
+{
 	Q_OBJECT
   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; }
 	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 operator=(const CellBase &src); // assignment operator
   CellBase operator=(const Vector &src);
   void SetChemical(int chem, double conc);
   inline void SetNewChem(int chem, double conc)
+  {
     new_chem[chem] = conc;
+  }
   void SetSource(int chem, double conc)
+  {
     source=true;
     source_chem = chem;
     source_conc = conc;
+  }
   // set chem 1 to conc in all membranes of this cell
   void SetTransporters(int chem, double conc);
   void UnfixNodes(void);
   void FixNodes(void);
   void UnsetSource(void) {
     source = false;
+  }
 	CellBase(const CellBase &src); // copy constructor
 	virtual bool BoundaryPolP(void) const { return false; }
     CellBase operator=(const CellBase &src); // assignment operator
     CellBase operator=(const Vector &src);
     void SetChemical(int chem, double conc);
     inline void SetNewChem(int chem, double conc) {
       new_chem[chem] = conc;
+    }
     void SetSource(int chem, double conc) {
       source=true;
       source_chem = chem;
       source_conc = conc;
+	}
 	// set chem 1 to conc in all membranes of this cell
     void SetTransporters(int chem, double conc);
     void UnfixNodes(void);
     void FixNodes(void);
     void UnsetSource(void) {
       source = false;
+    }
 	inline bool Source(void) { return source; }
     enum boundary_type {None, Noflux, SourceSink, SAM};
     static const char * boundary_type_names[4];
   inline 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]; }
     inline const char *BoundaryStr(void) { return boundary_type_names[boundary]; }
     ostream &print(ostream &os) const;
   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
     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();
     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;
 #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
     boundary_type SetBoundary(boundary_type bound) {
       if (bound!=None) {
+      }
       return boundary=bound;
+    }
     boundary_type ResetBoundary(void) {
       return boundary=None;
+    }
     boundary_type Boundary(void) const {
       return boundary;
+    }
     static int &NChem(void) {
       return static_data_members->nchem;
+    }
     double CalcArea(void) const;
     double RecalcArea(void) {
       return area = CalcArea();
     return ((c<0) || (c>=nchem)) ? 0 : chem[c];
+  }
   //void print_nblist(void) const;
   boundary_type SetBoundary(boundary_type bound)
+  {
     if (bound!=None) {
+    }
     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;
     return boundary=bound;
+  }
   boundary_type ResetBoundary(void) { return boundary=None; }
     inline int Index(void) const {
       return index;
+    }
   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(); }
     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;
+    }
   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 double Stiffness(void) {
       return stiffness;
+    }
     inline double EnlargeTargetArea(double da) {
       return target_area+=da;
+    }
     inline double Area(void) const {
       return area;
+    }
 	inline void Divide(void) {
 		flag_for_divide = true;
+	}
 	inline void DivideOverAxis(const Vector &v) {
 		division_axis = new Vector(v);
 		flag_for_divide = true;
+	}
   inline 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 double Circumference(void) const {
       double sum=0.;
       for (list<Wall *>::const_iterator w=walls.begin();
 	   w!=walls.end();
 	   w++) {
 	sum +=  (*w)->Length();
+      }
       return sum;
+    }
   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; }
 	QList<WallBase *> getWalls(void) {
 		QList<WallBase *> wall_list;
 		for (list<Wall *>::iterator i=walls.begin();
 			 i!=walls.end();
 			 i++) {
 			wall_list << *i;
+		}
 		return wall_list;
+	}
     void Dump(ostream &os) const;
 	QString printednodelist(void);
   inline void Divide(void) { flag_for_divide = true; }
     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);
   inline void DivideOverAxis(const Vector &v)
+  {
     division_axis = new Vector(v);
     flag_for_divide = true;
+  }
     // 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 double Circumference(void) const {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum +=  (*w)->Length();
+    }
     inline void Mark(void) {
       marked=true;
+    }
     inline void Unmark(void) {
       marked=false;
+    }
     inline bool Marked(void) const {
       return marked;
+    }
     return sum;
+  }
 	//! 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;
   QList<WallBase *> getWalls(void) {
     QList<WallBase *> wall_list;
     for (list<Wall *>::iterator i=walls.begin();
 	 i!=walls.end();
 	 i++) {
       wall_list << *i;
+    }
     //! The same, but now for the walls AND neighbors
     template<class P, class Op> P ReduceCellAndWalls(Op f) {
       P sum = 0;
       for (list<Wall *>::const_iterator w=walls.begin();
 	   w!=walls.end();
 	   w++) {
 	sum += ((*w)->c1 == this) ?
 	  f( ((*w)->c1), ((*w)->c2), *w ) :
 	  f( ((*w)->c2), ((*w)->c1), *w );
+      }
       return sum;
     return wall_list;
+  }
   void Dump(ostream &os) const;
   QString printednodelist(void);
   inline bool DeadP(void) { return dead; }
   inline void MarkDead(void) { dead  = true; }
   static double &BaseArea(void)
+  {
     return static_data_members->base_area;
+  }
   void CheckForDivision(void);
   // write flux from neighboring cells into "flux"
   void Flux(double *flux, double *D);
   inline bool FixedP(void) { return fixed; }
   inline bool Fix(void) {  FixNodes(); return (fixed=true); }
   inline bool Unfix(void) { UnfixNodes(); return (fixed=false);}
   inline void setCellVec(Vector cv) { cellvec = cv; }
   bool AtBoundaryP(void) const;
   static inline int &NCells(void)
+  {
     return static_data_members->ncells;
+  }
   inline void Mark(void)
+  {
     marked=true;
+  }
   inline void Unmark(void)
+  {
     marked=false;
+  }
   inline bool Marked(void) const {
     return marked;
+  }
   //! Returns the sum of chemical "chem" of this CellBase's neighbors
   double SumChemicalsOfNeighbors(int chem)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum +=  (*w)->Length() * ( (*w)->c1!=this ? (*w)->c1->Chemical(chem) : (*w)->c2->Chemical(chem) );
+    }
     //! 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;
     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;
+  }
     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;
   //! The same, but now for the walls AND neighbors
   template<class P, class Op> P ReduceCellAndWalls(Op f)
+  {
     P sum = 0;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += ((*w)->c1 == this) ?
 	f( ((*w)->c1), ((*w)->c2), *w ) :
 	f( ((*w)->c2), ((*w)->c1), *w );
+    }
     return sum;
+  }
   //! Sum transporters at this CellBase's side of the walls
   double SumTransporters(int ch)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += (*w)->getTransporter(this, ch);
+    }
     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;
     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();
+    }
 	inline int CellType(void) const { return cell_type; }
 	inline void SetCellType(int ct) { cell_type = ct; }
     return sum;
+  }
 	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; }
   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 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];
+		}
   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 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]; }
+  }
   inline double TargetLength() const { return target_length; }
   static inline CellsStaticDatamembers *GetStaticDataMemberPointer(void) { return static_data_members; }
  protected:
     list<Node *> nodes;
     void ConstructNeighborList(void);
 	long wall_list_index (Wall *elem) const;
   // (define a list of Node* iterators)
   typedef list < list<Node *>::iterator > ItList;
     // 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;
   int index;
     list<Wall *> walls;
     double *chem;
     double *new_chem;
     boundary_type boundary;
     mutable double area;
     double target_area;
     double target_length;
     double lambda_celllength;
   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]; }
     double stiffness; // stiffness like in Hogeweg (2000)
  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;
     bool fixed;
     bool pin_fixed;
     bool at_boundary;
     bool dead;
 	bool flag_for_divide;
 	Vector *division_axis;
 	int cell_type;
     // for length constraint
     mutable double intgrl_xx, intgrl_xy, intgrl_yy, intgrl_x, intgrl_y;
     bool source;
     Vector cellvec;
 	// STATIC DATAMEMBERS MOVED TO CLASS
 	static CellsStaticDatamembers *static_data_members;
 	double source_conc;
     int source_chem;
     // PRIVATE MEMBER FUNCTIONS
     inline static void ClearNCells(void) {
       NCells()=0;
+    }
     bool marked;
     int div_counter;
   double *chem;
   double *new_chem;
   boundary_type boundary;
   mutable double area;
   double target_area;
   double target_length;
   double lambda_celllength;
   double stiffness; // stiffness like in Hogeweg (2000)
   bool fixed;
   bool pin_fixed;
   bool at_boundary;
   bool dead;
   bool flag_for_divide;
   Vector *division_axis;
   int cell_type;
   // for length constraint
   mutable double intgrl_xx, intgrl_xy, intgrl_yy, intgrl_x, intgrl_y;
   bool source;
   Vector cellvec;
   // STATIC DATAMEMBERS MOVED TO CLASS
   static CellsStaticDatamembers *static_data_members;
   double source_conc;
   int source_chem;
   // PRIVATE MEMBER FUNCTIONS
   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) {
 	  nb = NULL; // assignment merely to obviate compilation warning
 	  return w->getTransporter( here, 1)  *  w->getInfluxVector(here);
 inline Vector PINdir(CellBase *here, CellBase *nb, Wall *w)
+{
   nb = NULL; // assignment merely to obviate compilation warning
   return w->getTransporter( here, 1)  *  w->getInfluxVector(here);
+}
 #endif
 /* finis*/

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

0 comments (0 inline, 0 general)