Laboratoire RDP » Biophysics Team » Cell Division Rule

#include "cell_division2.h"

#include "compute_barycenters.h"

#include "compute_shapes.h"

#include "constants.h"

#include <stdio.h>

#include <stdlib.h>

#include <omp.h>

#include "compute_areas.h"

#include "compute_cell_areas.h"

#include "compute_lengths.h"

#include "compute_wall_vertices.h"

/* this function reorganizes various lists after a division (cells_vertices, vertices_number_in_each_cell, wall_vertices, p, boundary, targets, target_lengths, target_areas) */

void cell_division2(double *vertices, int vertices_number, int *cells_vertices, int *vertices_number_in_each_cell, int cell_number, int *wall_vertices, int wall_number,

          double *barycenters, double *areas, double *cell_areas, double *lengths, double *target_lengths, double *shapes, double *targets,

          int dividing_cell, int *boundary, int *border, int adjacent_cells_number, int adjacent_cell1, int adjacent_cell2,

          int *daughter_cells_vertices_number, int *cell1, int *cell2, int *wall1, int *wall2){

//double old_area=cell_areas[dividing_cell];

double old_shape[3]={shapes[3*dividing_cell],shapes[3*dividing_cell+1],shapes[3*dividing_cell+2]};

double old_target_shape[3]={targets[3*dividing_cell],targets[3*dividing_cell+1],targets[3*dividing_cell+2]};

double old_shape_adjacent_cell1[3]={shapes[3*adjacent_cell1],shapes[3*adjacent_cell1+1],shapes[3*adjacent_cell1+2]};

double old_target_shape_adjacent_cell1[3]={targets[3*adjacent_cell1],targets[3*adjacent_cell1+1],targets[3*adjacent_cell1+2]};

double old_shape_adjacent_cell2[3]={shapes[3*adjacent_cell2],shapes[3*adjacent_cell2+1],shapes[3*adjacent_cell2+2]};

double old_target_shape_adjacent_cell2[3]={targets[3*adjacent_cell2],targets[3*adjacent_cell2+1],targets[3*adjacent_cell2+2]};

int old_boundary[vertices_number_in_each_cell[cell_number-1]];

for (int i=0;i<vertices_number_in_each_cell[cell_number-1];i++){

    old_boundary[i]=boundary[i];

}

int previous,j,k,delta,first,second,third;

/* saving of the old lists "vertices_number_in_each_cell" and "cells_vertices", usefull in the computation of the new ones */

int old_vertices_number_in_each_cell[cell_number];

for (int i=0;i<cell_number;i++){old_vertices_number_in_each_cell[i]=vertices_number_in_each_cell[i];}

int old_cells_vertices[old_vertices_number_in_each_cell[cell_number-1]];

for (int i=0;i<old_vertices_number_in_each_cell[cell_number-1];i++){old_cells_vertices[i]=cells_vertices[i];}

/* case 1: 2 adjacent cells have to be modified */

if (adjacent_cells_number==2){

    delta=daughter_cells_vertices_number[0]-(vertices_number_in_each_cell[dividing_cell+1]-vertices_number_in_each_cell[dividing_cell]);

/* case 1.1: the dividing cell has a smaller index than the adjacent cells */

if (dividing_cell<adjacent_cell1){ first=dividing_cell; second=adjacent_cell1; third=adjacent_cell2;

    for (int i=dividing_cell+1;i<adjacent_cell1+1;i++){vertices_number_in_each_cell[i]+=delta;}

    for (int i=adjacent_cell1+1;i<adjacent_cell2+1;i++){vertices_number_in_each_cell[i]+=delta+1;}

    for (int i=adjacent_cell2+1;i<cell_number;i++){vertices_number_in_each_cell[i]+=delta+2;}

}

/* case 1.2: the dividing cell has a bigger index than the adjacent cells */

else if (dividing_cell>adjacent_cell2){ first=adjacent_cell1; second=adjacent_cell2; third=dividing_cell;

    for (int i=adjacent_cell1+1;i<adjacent_cell2+1;i++){vertices_number_in_each_cell[i]+=1;}

    for (int i=adjacent_cell2+1;i<dividing_cell+1;i++){vertices_number_in_each_cell[i]+=2;}

    for (int i=dividing_cell+1;i<cell_number;i++){vertices_number_in_each_cell[i]+=delta+2;}

}

/* case 1.3: the dividing cell is between the adjacent cells */

else{ first=adjacent_cell1; second=dividing_cell; third=adjacent_cell2;

    for (int i=adjacent_cell1+1;i<dividing_cell+1;i++){vertices_number_in_each_cell[i]+=1;}

    for (int i=dividing_cell+1;i<adjacent_cell2+1;i++){vertices_number_in_each_cell[i]+=delta+1;}

    for (int i=adjacent_cell2+1;i<cell_number;i++){vertices_number_in_each_cell[i]+=delta+2;}

}

vertices_number_in_each_cell[cell_number]=vertices_number_in_each_cell[cell_number-1]+daughter_cells_vertices_number[1];

for (int i=vertices_number_in_each_cell[dividing_cell];i<vertices_number_in_each_cell[dividing_cell+1];i++){

    cells_vertices[i]=cell1[i-vertices_number_in_each_cell[dividing_cell]];}

k=0;

previous=vertices_number_in_each_cell[adjacent_cell1+1]-2;

for (int i=vertices_number_in_each_cell[adjacent_cell1];i<vertices_number_in_each_cell[adjacent_cell1+1]-1;i++){

    if (((wall1[1]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+i-vertices_number_in_each_cell[adjacent_cell1]] &&

            wall1[0]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+previous-vertices_number_in_each_cell[adjacent_cell1]])) && k==0){

        cells_vertices[i]=vertices_number-2; k++;}

    if (((wall2[1]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+i-vertices_number_in_each_cell[adjacent_cell1]] &&

            wall2[0]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+previous-vertices_number_in_each_cell[adjacent_cell1]])) && k==0){

        cells_vertices[i]=vertices_number-1; k++;}

    cells_vertices[i+k]=old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+i-vertices_number_in_each_cell[adjacent_cell1]];

    previous=i;

}

k=0;

previous=vertices_number_in_each_cell[adjacent_cell2+1]-2;

for (int i=vertices_number_in_each_cell[adjacent_cell2];i<vertices_number_in_each_cell[adjacent_cell2+1]-1;i++){

    if (((wall1[1]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell2]+i-vertices_number_in_each_cell[adjacent_cell2]] &&

            wall1[0]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell2]+previous-vertices_number_in_each_cell[adjacent_cell2]])) && k==0){

        cells_vertices[i]=vertices_number-2; k++;}

    if (((wall2[1]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell2]+i-vertices_number_in_each_cell[adjacent_cell2]] &&

            wall2[0]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell2]+previous-vertices_number_in_each_cell[adjacent_cell2]])) && k==0){

        cells_vertices[i]=vertices_number-1; k++;}

    cells_vertices[i+k]=old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell2]+i-vertices_number_in_each_cell[adjacent_cell2]];

    previous=i;

}

for (int i=vertices_number_in_each_cell[first+1];i<vertices_number_in_each_cell[second];i++){

    cells_vertices[i]=

    old_cells_vertices[old_vertices_number_in_each_cell[first+1]+i-vertices_number_in_each_cell[first+1]];}

for (int i=vertices_number_in_each_cell[second+1];i<vertices_number_in_each_cell[third];i++){

    cells_vertices[i]=

    old_cells_vertices[old_vertices_number_in_each_cell[second+1]+i-vertices_number_in_each_cell[second+1]];}

for (int i=vertices_number_in_each_cell[third+1];i<vertices_number_in_each_cell[cell_number-1];i++){

    cells_vertices[i]=old_cells_vertices[old_vertices_number_in_each_cell[third+1]+i-vertices_number_in_each_cell[third+1]];}

for (int i=vertices_number_in_each_cell[cell_number-1];i<vertices_number_in_each_cell[cell_number];i++){

    cells_vertices[i]=cell2[i-vertices_number_in_each_cell[cell_number-1]];}

}

/* case 2: 1 adjacent cell has to be modified */

if (adjacent_cells_number==1){

if (dividing_cell<adjacent_cell1){ first=dividing_cell; second=adjacent_cell1;

    delta=daughter_cells_vertices_number[0]-(vertices_number_in_each_cell[dividing_cell+1]-vertices_number_in_each_cell[dividing_cell]);

    for (int i=dividing_cell+1;i<adjacent_cell1+1;i++){vertices_number_in_each_cell[i]+=delta;}

    for (int i=adjacent_cell1+1;i<cell_number;i++){vertices_number_in_each_cell[i]+=delta+1;}

    vertices_number_in_each_cell[cell_number]=vertices_number_in_each_cell[cell_number-1]+daughter_cells_vertices_number[1];}

else if (dividing_cell>adjacent_cell1){ first=adjacent_cell1; second=dividing_cell;

    delta=daughter_cells_vertices_number[0]-(vertices_number_in_each_cell[dividing_cell+1]-vertices_number_in_each_cell[dividing_cell]);

    for (int i=adjacent_cell1+1;i<dividing_cell+1;i++){vertices_number_in_each_cell[i]+=1;}

    for (int i=dividing_cell+1;i<cell_number;i++){vertices_number_in_each_cell[i]+=delta+1;}

    vertices_number_in_each_cell[cell_number]=vertices_number_in_each_cell[cell_number-1]+daughter_cells_vertices_number[1];}

    for (int i=vertices_number_in_each_cell[dividing_cell];i<vertices_number_in_each_cell[dividing_cell+1];i++){

        cells_vertices[i]=cell1[i-vertices_number_in_each_cell[dividing_cell]];}

    k=0;

    previous=vertices_number_in_each_cell[adjacent_cell1+1]-2;

    for (int i=vertices_number_in_each_cell[adjacent_cell1];i<vertices_number_in_each_cell[adjacent_cell1+1]-1;i++){

        if (((wall1[1]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+i-vertices_number_in_each_cell[adjacent_cell1]] &&

              wall1[0]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+previous-vertices_number_in_each_cell[adjacent_cell1]])) && k==0){

            cells_vertices[i]=vertices_number-2; k++;}

        if (((wall2[1]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+i-vertices_number_in_each_cell[adjacent_cell1]] &&

              wall2[0]==old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+previous-vertices_number_in_each_cell[adjacent_cell1]])) && k==0){

            cells_vertices[i]=vertices_number-1; k++;}

        cells_vertices[i+k]=old_cells_vertices[old_vertices_number_in_each_cell[adjacent_cell1]+i-vertices_number_in_each_cell[adjacent_cell1]];

        previous=i;

    }

    for (int i=vertices_number_in_each_cell[first+1];i<vertices_number_in_each_cell[second];i++){

        cells_vertices[i]=

        old_cells_vertices[old_vertices_number_in_each_cell[first+1]+i-vertices_number_in_each_cell[first+1]];}

    for (int i=vertices_number_in_each_cell[second+1];i<vertices_number_in_each_cell[cell_number-1];i++){

        cells_vertices[i]=old_cells_vertices[old_vertices_number_in_each_cell[second+1]+i-vertices_number_in_each_cell[second+1]];}

    for (int i=vertices_number_in_each_cell[cell_number-1];i<vertices_number_in_each_cell[cell_number];i++){

        cells_vertices[i]=cell2[i-vertices_number_in_each_cell[cell_number-1]];}

}

/* case 3: no adjacent cell has to be modified */

    // impossible, except in very unusual cases

if (adjacent_cells_number==0){

    delta=daughter_cells_vertices_number[0]-(vertices_number_in_each_cell[dividing_cell+1]-vertices_number_in_each_cell[dividing_cell]);

    for (int i=dividing_cell+1;i<cell_number;i++){vertices_number_in_each_cell[i]+=delta;}

    vertices_number_in_each_cell[cell_number]=vertices_number_in_each_cell[cell_number-1]+daughter_cells_vertices_number[1];

    for (int i=vertices_number_in_each_cell[dividing_cell];i<vertices_number_in_each_cell[dividing_cell+1];i++){

        cells_vertices[i]=cell1[i-vertices_number_in_each_cell[dividing_cell]];}

    for (int i=vertices_number_in_each_cell[dividing_cell+1];i<vertices_number_in_each_cell[cell_number-1];i++){

        cells_vertices[i]=

        old_cells_vertices[old_vertices_number_in_each_cell[dividing_cell+1]+i-vertices_number_in_each_cell[dividing_cell+1]];}

    for (int i=vertices_number_in_each_cell[cell_number-1];i<vertices_number_in_each_cell[cell_number];i++){

        cells_vertices[i]=cell2[i-vertices_number_in_each_cell[cell_number-1]];}

}

///* concentrations in the daughter cells are the concentration in the mother */

//a[cell_number-1]=a[dividing_cell];

    // tracking of the walls which are on the boundary

/* tracking of the walls which were not modified by the division */

int next,previous2,previous3;

for (int i=0;i<cell_number-1;i++){

    previous=vertices_number_in_each_cell[i+1]-1;

    for (j=vertices_number_in_each_cell[i];j<vertices_number_in_each_cell[i+1];j++){

        previous2=old_vertices_number_in_each_cell[i+1]-1;

        for (k=old_vertices_number_in_each_cell[i];k<old_vertices_number_in_each_cell[i+1];k++){

            if (cells_vertices[previous]==old_cells_vertices[previous2] && cells_vertices[j]==old_cells_vertices[k]){

//            p[j]=old_p[k];

            boundary[j]=old_boundary[k];

            }

        previous2=k;}

    previous=j;}

}

    /* tracking of the walls from cell #cell_number which were not modified by the division */

for (int i=vertices_number_in_each_cell[cell_number-1];i<vertices_number_in_each_cell[cell_number];i++){

    previous=i-1; if (i==vertices_number_in_each_cell[cell_number-1]){previous=vertices_number_in_each_cell[cell_number]-1;}

    previous2=old_vertices_number_in_each_cell[dividing_cell+1]-1;

    for (k=old_vertices_number_in_each_cell[dividing_cell];k<old_vertices_number_in_each_cell[dividing_cell+1];k++){

        if (cells_vertices[previous]==old_cells_vertices[previous2] && cells_vertices[i]==old_cells_vertices[k]){

//        p[i]=old_p[k];

        boundary[i]=old_boundary[k];

        }

    previous2=k;}

}

    /* tracking of the walls from the daughters which were modified by the division */

for (int i=old_vertices_number_in_each_cell[dividing_cell];i<old_vertices_number_in_each_cell[dividing_cell+1];i++){

    previous=i-1; if (i==old_vertices_number_in_each_cell[dividing_cell]){previous=old_vertices_number_in_each_cell[dividing_cell+1]-1;}

    previous2=vertices_number_in_each_cell[dividing_cell+1]-1;

    for (j=vertices_number_in_each_cell[dividing_cell];j<vertices_number_in_each_cell[dividing_cell+1];j++){

        previous3=vertices_number_in_each_cell[cell_number]-1;

        for (k=vertices_number_in_each_cell[cell_number-1];k<vertices_number_in_each_cell[cell_number];k++){

            if ((old_cells_vertices[previous]==cells_vertices[previous2] && cells_vertices[previous3]==cells_vertices[j]) &&

                (old_cells_vertices[i]==cells_vertices[k])){

//                    p[j]=old_p[i];

//                    p[k]=old_p[i];

                    boundary[j]=old_boundary[i];

                    boundary[k]=old_boundary[i];

            }

            if ((old_cells_vertices[previous]==cells_vertices[previous3] && cells_vertices[previous2]==cells_vertices[k]) &&

                (old_cells_vertices[i]==cells_vertices[j])){

//                    p[j]=old_p[previous];

//                    p[k]=old_p[previous];

                    boundary[j]=old_boundary[i];

                    boundary[k]=old_boundary[i];

            }

        previous3=k;}

    previous2=j;}

}

    /* tracking of the new cell wall */

for (int i=vertices_number_in_each_cell[dividing_cell];i<vertices_number_in_each_cell[dividing_cell+1];i++){

    previous2=i-1; if(i==vertices_number_in_each_cell[dividing_cell]){previous2=vertices_number_in_each_cell[dividing_cell+1]-1;}

    previous3=vertices_number_in_each_cell[cell_number]-1;

    for (k=vertices_number_in_each_cell[cell_number-1];k<vertices_number_in_each_cell[cell_number];k++){

        if (cells_vertices[previous2]==cells_vertices[k] && cells_vertices[i]==cells_vertices[previous3]){

//            p[i]=production_coeff_p/degradation_coeff_p;

//            p[k]=production_coeff_p/degradation_coeff_p;

            boundary[i]=0;

            boundary[k]=0;

            }

    previous3=k;}

}

    /* tracking of the walls from the neighbours which were modified by the division */

if (adjacent_cells_number>0){

    previous2=old_vertices_number_in_each_cell[adjacent_cell1+1]-1;

    for (int i=old_vertices_number_in_each_cell[adjacent_cell1];i<old_vertices_number_in_each_cell[adjacent_cell1+1];i++){

        previous=vertices_number_in_each_cell[adjacent_cell1+1]-1;

        for (j=vertices_number_in_each_cell[adjacent_cell1];j<vertices_number_in_each_cell[adjacent_cell1+1];j++){

            next=j+1; if (next==vertices_number_in_each_cell[adjacent_cell1+1]){next=vertices_number_in_each_cell[adjacent_cell1];}

            if (cells_vertices[next]==old_cells_vertices[i] && cells_vertices[previous]==old_cells_vertices[previous2]){

//                p[j]=old_p[i];

//                p[next]=old_p[i];

                boundary[j]=old_boundary[i];

                boundary[next]=old_boundary[i];

                }

        previous=j;}

    previous2=i;}

}

if (adjacent_cells_number==2){

    previous2=old_vertices_number_in_each_cell[adjacent_cell2+1]-1;

    for (int i=old_vertices_number_in_each_cell[adjacent_cell2];i<old_vertices_number_in_each_cell[adjacent_cell2+1];i++){

        previous=vertices_number_in_each_cell[adjacent_cell2+1]-1;

        for (j=vertices_number_in_each_cell[adjacent_cell2];j<vertices_number_in_each_cell[adjacent_cell2+1];j++){

            next=j+1; if (next==vertices_number_in_each_cell[adjacent_cell2+1]){next=vertices_number_in_each_cell[adjacent_cell2];}

            if (cells_vertices[next]==old_cells_vertices[i] && cells_vertices[previous]==old_cells_vertices[previous2]){

//                p[j]=old_p[i];

//                p[next]=old_p[i];

                boundary[j]=old_boundary[i];

                boundary[next]=old_boundary[i];

                }

        previous=j;}

    previous2=i;}

}

    // updating the list "wall_vertices" and the lengths of the walls

double old_wall_vertices[2*wall_number-6];

for (int i=0;i<2*wall_number-6;i++){old_wall_vertices[i]=wall_vertices[i];}

double old_target_lengths[wall_number-3];

for (int i=0;i<wall_number-3;i++){old_target_lengths[i]=target_lengths[i];}

double old_length1, old_target_length1, old_length2, old_target_length2;

for (int i=0;i<wall_number-3;i++){

    if ((wall_vertices[2*i]==wall1[0] && wall_vertices[2*i+1]==wall1[1]) || (wall_vertices[2*i]==wall1[1] && wall_vertices[2*i+1]==wall1[0])){

        old_length1=lengths[i]; old_target_length1=target_lengths[i];

    }

    if ((wall_vertices[2*i]==wall2[0] && wall_vertices[2*i+1]==wall2[1]) || (wall_vertices[2*i]==wall2[1] && wall_vertices[2*i+1]==wall2[0])){

        old_length2=lengths[i]; old_target_length2=target_lengths[i];

    }

}

compute_wall_vertices( cells_vertices, vertices_number_in_each_cell, cell_number, wall_vertices);

compute_lengths(vertices, wall_vertices, wall_number, lengths);

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

    for (j=0;j<wall_number-3;j++){

        if ((wall_vertices[2*i]==old_wall_vertices[2*j] && wall_vertices[2*i+1]==old_wall_vertices[2*j+1]) || (wall_vertices[2*i]==old_wall_vertices[2*j+1] && wall_vertices[2*i+1]==old_wall_vertices[2*j])){

            target_lengths[i]=old_target_lengths[j]; //goto next_wall;

        }

    }

    if ((wall_vertices[2*i]==wall1[0] && wall_vertices[2*i+1]==vertices_number-2) || (wall_vertices[2*i]==wall1[1] && wall_vertices[2*i+1]==vertices_number-2) ||

        (wall_vertices[2*i+1]==wall1[0] && wall_vertices[2*i]==vertices_number-2) || (wall_vertices[2*i+1]==wall1[1] && wall_vertices[2*i]==vertices_number-2)){

        target_lengths[i]=lengths[i]*old_target_length1/old_length1;

    }

    if ((wall_vertices[2*i]==wall2[0] && wall_vertices[2*i+1]==vertices_number-1) || (wall_vertices[2*i]==wall2[1] && wall_vertices[2*i+1]==vertices_number-1) ||

        (wall_vertices[2*i+1]==wall2[0] && wall_vertices[2*i]==vertices_number-1) || (wall_vertices[2*i+1]==wall2[1] && wall_vertices[2*i]==vertices_number-1)){

        target_lengths[i]=lengths[i]*old_target_length2/old_length2;

    }

    if ((wall_vertices[2*i]==vertices_number-1 && wall_vertices[2*i+1]==vertices_number-2) ||

        (wall_vertices[2*i+1]==vertices_number-1 && wall_vertices[2*i]==vertices_number-2) ){

        target_lengths[i]=lengths[i];

    }

}

/* computation of values which are modified by the division */ //printf("cell division 2\n"); int bug[1]={0};

compute_barycenters(vertices,vertices_number,cells_vertices,vertices_number_in_each_cell,cell_number,barycenters);

compute_shapes(vertices, cells_vertices, vertices_number_in_each_cell, cell_number, barycenters, shapes);

compute_areas(vertices, cells_vertices, vertices_number_in_each_cell, cell_number, areas);

compute_cell_areas(vertices, cells_vertices, vertices_number_in_each_cell, cell_number, areas, cell_areas);

    // definition of the new targets, to keep stress constant, on the daughters

targets[3*dividing_cell]=shapes[3*dividing_cell]+(shapes[3*dividing_cell]+shapes[3*dividing_cell+1])*(old_target_shape[0]-old_shape[0])/(old_shape[0]+old_shape[1]);

targets[3*dividing_cell+1]=shapes[3*dividing_cell+1]+(shapes[3*dividing_cell]+shapes[3*dividing_cell+1])*(old_target_shape[1]-old_shape[1])/(old_shape[0]+old_shape[1]);

targets[3*dividing_cell+2]=shapes[3*dividing_cell+2]+(shapes[3*dividing_cell]+shapes[3*dividing_cell+1])*(old_target_shape[2]-old_shape[2])/(old_shape[0]+old_shape[1]);

targets[3*(cell_number-1)]=shapes[3*(cell_number-1)]+(shapes[3*(cell_number-1)]+shapes[3*(cell_number-1)+1])*(old_target_shape[0]-old_shape[0])/(old_shape[0]+old_shape[1]);

targets[3*(cell_number-1)+1]=shapes[3*(cell_number-1)+1]+(shapes[3*(cell_number-1)]+shapes[3*(cell_number-1)+1])*(old_target_shape[1]-old_shape[1])/(old_shape[0]+old_shape[1]);

targets[3*(cell_number-1)+2]=shapes[3*(cell_number-1)+2]+(shapes[3*(cell_number-1)]+shapes[3*(cell_number-1)+1])*(old_target_shape[2]-old_shape[2])/(old_shape[0]+old_shape[1]);

    // definition of the new targets, to keep stress constant, on the neighbours

if (adjacent_cells_number>0){

targets[3*adjacent_cell1]=shapes[3*adjacent_cell1]+(shapes[3*adjacent_cell1]+shapes[3*adjacent_cell1+1])*(old_target_shape_adjacent_cell1[0]-old_shape_adjacent_cell1[0])/(old_shape_adjacent_cell1[0]+old_shape_adjacent_cell1[1]);

targets[3*adjacent_cell1+1]=shapes[3*adjacent_cell1+1]+(shapes[3*adjacent_cell1]+shapes[3*adjacent_cell1+1])*(old_target_shape_adjacent_cell1[1]-old_shape_adjacent_cell1[1])/(old_shape_adjacent_cell1[0]+old_shape_adjacent_cell1[1]);

targets[3*adjacent_cell1+2]=shapes[3*adjacent_cell1+2]+(shapes[3*adjacent_cell1]+shapes[3*adjacent_cell1+1])*(old_target_shape_adjacent_cell1[2]-old_shape_adjacent_cell1[2])/(old_shape_adjacent_cell1[0]+old_shape_adjacent_cell1[1]);

if (adjacent_cells_number==2){

targets[3*adjacent_cell2]=shapes[3*adjacent_cell2]+(shapes[3*adjacent_cell2]+shapes[3*adjacent_cell2+1])*(old_target_shape_adjacent_cell2[0]-old_shape_adjacent_cell2[0])/(old_shape_adjacent_cell2[0]+old_shape_adjacent_cell2[1]);

targets[3*adjacent_cell2+1]=shapes[3*adjacent_cell2+1]+(shapes[3*adjacent_cell2]+shapes[3*adjacent_cell2+1])*(old_target_shape_adjacent_cell2[1]-old_shape_adjacent_cell2[1])/(old_shape_adjacent_cell2[0]+old_shape_adjacent_cell2[1]);

targets[3*adjacent_cell2+2]=shapes[3*adjacent_cell2+2]+(shapes[3*adjacent_cell2]+shapes[3*adjacent_cell2+1])*(old_target_shape_adjacent_cell2[2]-old_shape_adjacent_cell2[2])/(old_shape_adjacent_cell2[0]+old_shape_adjacent_cell2[1]);

}

}

// tracking the cells which were on the border of the tissue (this is just inherited from the mother)

border[dividing_cell]=0;

for (int j=vertices_number_in_each_cell[dividing_cell]; j<vertices_number_in_each_cell[dividing_cell+1];j++){

    if (boundary[j]==1.){ border[dividing_cell]=1; }

}

border[cell_number-1]=0;

for (int j=vertices_number_in_each_cell[cell_number-1]; j<vertices_number_in_each_cell[cell_number];j++){

    if (boundary[j]==1.){ border[cell_number-1]=1; }

}

}