#

#  The Virtual Leaf is distributed in the hope that it will be useful,

#  but WITHOUT ANY WARRANTY; without even the implied warranty of

#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#  GNU General Public License for more details.

#

#  You should have received a copy of the GNU General Public License

#  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.

#

#  Copyright 2010 Roeland Merks.

#

CONFIG += qt

QMAKE_CXXFLAGS += -fexceptions

QMAKE_CXXFLAGS_DEBUG += -g3

QMAKE_CXXFLAGS_DEBUG += -DQDEBUG

#REACTIONS = reactions_auxin_growth.h 

#REACTIONS = reactions_meinhardt.h

#REACTIONS = reactions_pce_growth.h

DEFINES += QTGRAPHICS

DEFINES += REACTIONS_HEADER=$${REACTIONS}

DEFINES += REACTIONS_HEADER_STRING=\"$${REACTIONS}\"

#

#  The Virtual Leaf is distributed in the hope that it will be useful,

#  but WITHOUT ANY WARRANTY; without even the implied warranty of

#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#  GNU General Public License for more details.

#

#  You should have received a copy of the GNU General Public License

#  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.

#

#  Copyright 2010 Roeland Merks.

#

CONFIG += release

CONFIG -= debug

CONFIG += plugin

BINDIR = ../../bin

DEFINES = QTGRAPHICS # VLEAFPLUGIN

DESTDIR = $${BINDIR}/models

TARGET = test

HEADERS = ../simplugin.h $${TARGET}plugin.h  

QMAKE_CXXFLAGS += -fexceptions -I..

QMAKE_CXXFLAGS_DEBUG += -g3

QMAKE_CXXFLAGS_DEBUG += -DQDEBUG

	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];

	}

	//extern double auxin_account;

	//auxin_account += daughter->chem[0];

	for (int i=0;i<NChem();i++) {

		daughter->new_chem[i]=new_chem[i];

	}

	daughter->boundary=boundary;

	daughter->m=m;

	daughter->target_area=target_area/2.;

	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;

}

CellBase::CellBase(double x,double y,double z) : QObject(), Vector(x,y,z)

{

#ifndef VLEAFPLUGIN

	if (static_data_members == 0) {

		static_data_members = new CellsStaticDatamembers();

	}

#endif

	chem=new double[NChem()];

	for (int i=0;i<NChem();i++) {

	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;

}

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++) {

	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;

}

CellBase CellBase::operator=(const CellBase &src) {

	Vector::operator=(src);

	//  QObject::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];

	}

	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;

	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;

}

	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;

	  //cerr << "CellBase " << index << " is dying. " << endl;

  }

	CellBase(const CellBase &src); // copy constructor

	virtual bool BoundaryPolP(void) const { return false; } 

	//  CellBase(const Vector &src); // not allowed (we cannot know to which mesh 

	/// the CellBase will belong...)

    CellBase operator=(const CellBase &src); // assignment operator

    CellBase operator=(const Vector &src);

    }

    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 double Circumference(void) const {

      double sum=0.;

      for (list<Wall *>::const_iterator w=walls.begin();

	   w!=walls.end();

	   w++) {

	sum +=  (*w)->Length();

      }

      return sum;

    }

    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;

	int cell_type;

    //double length;

    //Vector meanflux;

    //int valence;

    // for length constraint

    mutable double intgrl_xx, intgrl_xy, intgrl_yy, intgrl_x, intgrl_y;

    bool source;

    Vector cellvec;

       c++) {

    //(*cr)(*c, &(derivs[i]));

	  plugin->CellDynamics(*c, &(derivs[i]));

	  i+=nchems;

  }

  for (list<Wall *>::iterator w=walls.begin();

       w!=walls.end();

       w++) {

   // (*wr)(*w, &(derivs[i]), &(derivs[i+nchems]));

	  plugin->WallDynamics(*w,  &(derivs[i]), &(derivs[i+nchems]));

    // Transport function adds to derivatives of cell chemicals

	  //(*tf)(*w, &(derivs[(*w)->c1->Index() * nchems]),

      //&(derivs[(*w)->c2->Index() * nchems] ) );

    i+=2*nchems;

  }

}

void Mesh::setValues(double x, double *y) {

  //int nwalls = walls.size();

  //int ncells = cells.size();

		}

	}

	void DoCellHouseKeeping(void) {

		vector<Cell *> current_cells = cells;

		for (vector<Cell *>::iterator i = current_cells.begin();

			 i != current_cells.end();

			 i ++) {

			plugin->CellHouseKeeping(**i);

			// Call functions of Cell that cannot be called from CellBase, including Division

			if ((*i)->flag_for_divide) {

				(*i)->flag_for_divide=false;

			}

		}

	}

/*	template<class Op1, class Cont> void ExtractFromCells(Op1 f, Cont res) {

		for (vector<Cell>::iterator i=cells.begin();

			 i!=cells.end();

			 i++) {

			*(res++) = ( f(*i) );

		}

	}*/