Ejemplo n.º 1
0
Agent* WorldAgentFactoryI::createAgent() {
	// open up an inputstream
//	cerr << this->inputname << endl;
	ifstream input(this->inputname.c_str());

	// create world agent and get his database
	Agent *world = new Agent();
	Hive::Database *db = world->getDatabase();

	// add the time counter to the world
	DoubleData *localworldtime = new DoubleData("localworldtime",0.0);
	db->addData(localworldtime->getName(),localworldtime);

	DoubleData *eqTime         = new DoubleData("eqTime", 0);
	db->addData(eqTime->getName(), eqTime);

	DoubleData *dt = new DoubleData("dt", 0);
	db->addData(dt);

	IntegerData *numberofcells = new IntegerData("numberofcells", this->numbercells);
	db->addData(numberofcells->getName(), numberofcells);

	// data structure for knowing which cell is stored at which index in the various vectors
	// that the world agent has
	// maps agent_id (key) on to vector index (value)
	MapIntIntData *local_index_map = new MapIntIntData("local_index_map");
	for (int i=0; i<this->numbercells; i++) {
		//assume agent_ids start at 1 (because the world is agent zero)
		local_index_map->insert(i+1,i);

		//cout<<"adding to local index map: ["<<i+1<<"]: => "<<i<<endl;
	}
	db->addData(local_index_map->getName(),local_index_map);

	// maps vector_index (key) onto agent_id
	// this is needed for outputing the positions of the cells
	MapIntIntData *index_agentid_map = new MapIntIntData("indexagentidmap");
	for (int i=0; i<this->numbercells; i++) {
		// again, agent_ids = i+1
		index_agentid_map->insert(i,i+1);
	}
	db->addData(index_agentid_map->getName(), index_agentid_map);

	// add data structure to the world in which it can store the cell positions
	TVectorData<TVectorData<double>* > *cell_positions = new TVectorData<TVectorData<double>* > ("cellpositions","tvectordata_double_matrix");
	cell_positions->reserveSize(this->numbercells);

	// add data_structure for direction and up vector of the individual cells
	TVectorData<TVectorData<double>* > *cell_dir_vecs = new TVectorData<TVectorData<double>* > ("celldirvecs", "tvectordata_doublematrix");
	cell_dir_vecs->reserveSize(this->numbercells);

	TVectorData<TVectorData<double>* > *cell_up_vecs  = new TVectorData<TVectorData<double>* > ("cellupvecs", "tvectordata_doublematrix");
	cell_up_vecs->reserveSize(this->numbercells);

	for (int i=0; i<this->numbercells;i++) {
		(*cell_positions)[i] = new TVectorData<double> ("position", "tvectordata_double");
		(*cell_positions)[i]->reserveSize(3);
		(*cell_dir_vecs)[i]  = new TVectorData<double> ("direction", "tvectordata_double");
		(*cell_dir_vecs)[i]->reserveSize(3);
		/// this needs to be a unit-vector.
		cell_dir_vecs->at(i)->at(0) = 1.; cell_dir_vecs->at(i)->at(1) = 0.; cell_dir_vecs->at(i)->at(2) = 0;
		(*cell_up_vecs)[i]   = new TVectorData<double> ("up", "tvectordata_double");
		(*cell_up_vecs)[i]->reserveSize(3);
		cell_up_vecs->at(i)->at(0) = 0; cell_up_vecs->at(i)->at(1) = 1; cell_up_vecs->at(i)->at(2) = 0;
	}
	db->addData(cell_positions->getName(), cell_positions);
	db->addData(cell_dir_vecs->getName(), cell_dir_vecs);
	db->addData(cell_up_vecs->getName(), cell_up_vecs);

	// data structure storing how much a cell wishes to consume
	// we will also use it to store the actual concentration that gets consumed by the cells
	TVectorData<double> *desired_cell_consumption = new TVectorData<double>("desired_cell_consumption", "tvectordata_double");
	desired_cell_consumption->reserveSize(this->numbercells);
	db->addData(desired_cell_consumption->getName(), desired_cell_consumption);

	// time step for movement of the cells
	DoubleData *movement_dt = new DoubleData("movement_dt",1.);
	db->addData(movement_dt->getName(), movement_dt);

	/// speed of cells (is that the same for all the cells?)
	//	DoubleData *cellspeed = new DoubleData("cellspeed",0.1);
	//	db->addData(cellspeed->getName(), cellspeed);

	TVectorData<double> *cellspeeds = new TVectorData<double>("cellspeeds", "tvector_double");
	cellspeeds->reserveSize(this->numbercells);
	for (int i=0; i<this->numbercells; i++)
		cellspeeds->at(i) = 20.0;
	db->addData(cellspeeds->getName(), cellspeeds);

	TVectorData<int> *cell_wants_to_move = new TVectorData<int>("cell_wants_to_move", "tvector_bool");
	cell_wants_to_move->reserveSize(this->numbercells);
	for (int i=0; i<this->numbercells; i++)
		cell_wants_to_move->at(i) = (int)true;
	db->addData(cell_wants_to_move->getName(), cell_wants_to_move);

	DoubleData *output_interval = new DoubleData("output_interval",this->output_interval);
	db->addData(output_interval->getName(), output_interval);


	BoolData *isGridEnv = new BoolData("is_grid_environment",false);
	db->addData(isGridEnv);



	if(!this->isBlindAgent) {
		cerr << "# cells are of type: ECOLI" << endl;
		// add data structures to the world that are unique to the E.coli model

		// add data structure to the world in which it can store the swimming states of all the cells
		TVectorData<int> *swimming_states = new TVectorData<int>("swimmingstates", "tvectordata_int");
		swimming_states->reserveSize(this->numbercells);
		db->addData(swimming_states->getName(), swimming_states);

		// add data structure to the world in whihc it stores the old swimming states of all the cells
		TVectorData<int> *last_swimming_states = new TVectorData<int>("lastswimmingstates", "tvectordata_int");
		last_swimming_states->reserveSize(this->numbercells);
		db->addData(last_swimming_states->getName(), last_swimming_states);

		// rotational diffusion constant of the cells
		DoubleData *rotdiffconst = new DoubleData("rotational_diffusion_constant",0.062);
		db->addData(rotdiffconst->getName(), rotdiffconst);
	} else {
		cerr << "# cells are of type: BLIND" << endl;

		// add data object needed by the blind searcher, which is the
		// next angle to use during turns.  Default to zero and must be
		// overridden by the agent
		TVectorData<double> *nextTurnAngles = new TVectorData<double>("cellnextturnangle", "tvector_double");
		nextTurnAngles->reserveSize(this->numbercells);
		for (int i=0; i<this->numbercells; i++)
			nextTurnAngles->at(i) = 0;
		db->addData(nextTurnAngles->getName(), nextTurnAngles);
	}



	// do the parsing of the system file. we can extend this later on if more information is needed.

	if(!input.is_open()) {
		cerr<<"did not open world file. quitting.";
		exit(1);
	}

	input.seekg(0,ios_base::beg);
	string line = "";
	istringstream iss;
	string environ_type;
	string cellpos_init_type;
	CellPositionInitialiser cpi;
	while (getline(input,line)) {
		if (line == "TYPE") {
			while (getline(input,line) && line != "END") {
				if (line.substr(0,1)!="#" && line != "") {
					iss.clear();
					iss.str(line);
					iss >> environ_type;
					if (environ_type == "linear") {
						cerr << "# creating linear environment" << endl;
						OneDLinearMathFunctionData *environ1 = new OneDLinearMathFunctionData("environment");
						double s, yi;
						iss >> s; iss >> yi;
						environ1->setSlope(s);
						environ1->setYIntercept(yi);
						db->addData(environ1->getName(), environ1);
					} else if (environ_type == "exponential") {
						cerr << "# creating exponential environment" << endl;
						OneDExponentialMathFunctionData *environ2 = new OneDExponentialMathFunctionData("environment");
						double o, p;
						iss >> o, iss >> p;
						environ2->setOffset(o);
						environ2->setParameter(p);
						db->addData(environ2->getName(), environ2);
					} else if (environ_type == "pointsource") {
Ejemplo n.º 2
0
Agent* WorldAgentFactoryI::createAgent() {
	// open up an inputstream
	ifstream input(this->inputname.c_str());

	// create world agent and get his database
	Agent *world = new Agent();
	Hive::Database *db = world->getDatabase();

	// add the time counter to the world
	DoubleData *localworldtime = new DoubleData("localworldtime",0.0);
	db->addData(localworldtime->getName(),localworldtime);

	DoubleData *eqTime         = new DoubleData("eqTime", 0);
	db->addData(eqTime->getName(), eqTime);

	DoubleData *dt = new DoubleData("dt", 1.0);
	db->addData(dt);

	IntegerData *numberofcells = new IntegerData("numberofcells", this->numbercells);
	db->addData(numberofcells->getName(), numberofcells);

	// data structure for knowing which cell is stored at which index in the various vectors
	// that the world agent has
	// maps agent_id (key) on to vector index (value)
	MapIntIntData *local_index_map = new MapIntIntData("local_index_map");
	for (int i=0; i<this->numbercells; i++) {
		//assume agent_ids start at 1 (because the world is agent zero)
		local_index_map->insert(i+1,i);
		//cout<<"adding to local index map: ["<<i+1<<"]: => "<<i<<endl;
	}
	db->addData(local_index_map->getName(),local_index_map);

	// maps vector_index (key) onto agent_id
	// this is needed for outputing the positions of the cells
	MapIntIntData *index_agentid_map = new MapIntIntData("indexagentidmap");
	for (int i=0; i<this->numbercells; i++) {
		// again, agent_ids = i+1
		index_agentid_map->insert(i,i+1);
	}
	db->addData(index_agentid_map->getName(), index_agentid_map);

	// ----------------- DATA STRUCTURES FOR CELL MOVEMENT ------------------------------
	// add data structure to the world in which it can store the cell positions
	TVectorData<TVectorData<double>* > *cell_positions = new TVectorData<TVectorData<double>* > ("cellpositions","tvectordata_double_matrix");
	cell_positions->reserveSize(this->numbercells);

	// add data_structure for direction and up vector of the individual cells
	TVectorData<TVectorData<double>* > *cell_dir_vecs = new TVectorData<TVectorData<double>* > ("celldirvecs", "tvectordata_doublematrix");
	cell_dir_vecs->reserveSize(this->numbercells);

	TVectorData<TVectorData<double>* > *cell_up_vecs  = new TVectorData<TVectorData<double>* > ("cellupvecs", "tvectordata_doublematrix");
	cell_up_vecs->reserveSize(this->numbercells);

	for (int i=0; i<this->numbercells;i++) {
		(*cell_positions)[i] = new TVectorData<double> ("position", "tvectordata_double");
		(*cell_positions)[i]->reserveSize(3);
		(*cell_dir_vecs)[i]  = new TVectorData<double> ("direction", "tvectordata_double");
		(*cell_dir_vecs)[i]->reserveSize(3);
		/// this needs to be a unit-vector.
		cell_dir_vecs->at(i)->at(0) = 1.; cell_dir_vecs->at(i)->at(1) = 0.; cell_dir_vecs->at(i)->at(2) = 0;
		(*cell_up_vecs)[i]   = new TVectorData<double> ("up", "tvectordata_double");
		(*cell_up_vecs)[i]->reserveSize(3);
		cell_up_vecs->at(i)->at(0) = 0; cell_up_vecs->at(i)->at(1) = 1; cell_up_vecs->at(i)->at(2) = 0;
	}
	db->addData(cell_positions->getName(), cell_positions);
	db->addData(cell_dir_vecs->getName(), cell_dir_vecs);
	db->addData(cell_up_vecs->getName(), cell_up_vecs);

	// cellspeeds
	TVectorData<double> *cellspeeds = new TVectorData<double>("cellspeeds", "tvector_double");
	cellspeeds->reserveSize(this->numbercells);
	for (int i=0; i<this->numbercells; i++)
		cellspeeds->at(i) = 20.0;
	db->addData(cellspeeds->getName(), cellspeeds);

	// DATA STRUCTURE FOR METABOLISM
	// data structure for storing how much a cell wishes to consume
	// we will also use it to store the actual concentration that gets consumed by the cells
	TVectorData<double> *desired_cell_consumption = new TVectorData<double>("desired_cell_consumption", "tvectordata_double");
	desired_cell_consumption->reserveSize(this->numbercells);
	db->addData(desired_cell_consumption->getName(), desired_cell_consumption);

	// DATA FOR OUTPUT
	DoubleData *output_interval = new DoubleData("output_interval",this->output_interval);
	db->addData(output_interval->getName(), output_interval);

	// SPECIFIC DATA FOR EITHER ECOLIs OR BLIND AGENTS
	// add data structures to the world that are unique to the E.coli model
	if(!this->isBlindAgent) {
		cerr << "# cells are of type: ECOLI" << endl;
		// add data structure to the world in which it can store the swimming states of all the cells
		TVectorData<int> *swimming_states = new TVectorData<int>("swimmingstates", "tvectordata_int");
		swimming_states->reserveSize(this->numbercells);
		db->addData(swimming_states->getName(), swimming_states);

		// add data structure to the world in whihc it stores the old swimming states of all the cells
		TVectorData<int> *last_swimming_states = new TVectorData<int>("lastswimmingstates", "tvectordata_int");
		last_swimming_states->reserveSize(this->numbercells);
		db->addData(last_swimming_states->getName(), last_swimming_states);

		// rotational diffusion constant of the cells
		DoubleData *rotdiffconst = new DoubleData("rotational_diffusion_constant",0.062);
		db->addData(rotdiffconst->getName(), rotdiffconst);
	} else { // add data object needed by the blind searcher, which is the
		cerr << "# cells are of type: BLIND" << endl;
		// next angle to use during turns.  Default to zero and must be overwritten by the agent
		TVectorData<double> *nextTurnAngles = new TVectorData<double>("cellnextturnangle", "tvector_double");
		nextTurnAngles->reserveSize(this->numbercells);
		for (int i=0; i<this->numbercells; i++)
			nextTurnAngles->at(i) = 0;
		db->addData(nextTurnAngles->getName(), nextTurnAngles);
	}


	// <------ DATA FOR ENVIRONMENT --------------
	// we read the environment from a file.
	BoolData *isGridEnv = new BoolData("is_grid_environment",false);
	db->addData(isGridEnv);

	// do the parsing of the system file. we can extend this later on if more information is needed.
	// not optimal, arose from our need to quickly change environements without having to change the code
	if(!input.is_open()) {
		cerr<<"did not open world file. quitting.";
		exit(1);
	}
	input.seekg(0,ios_base::beg);
	string line = "";
	istringstream iss;
	string environ_type;
	string cellpos_init_type;
	CellPositionInitialiser cpi;
	/// we need a vector of environments as we want to have multiple pointsources
	TVectorData<MathFunctionData* > *environments = new TVectorData<MathFunctionData*> ("environments", "tvector_mathfunctiondata");
	db->addData(environments);
	/// we need a vector of birth-times for the environments
	TVectorData<double> *birthtimes = new TVectorData<double> ("birthtimes_of_environments", "tvector_double");
	db->addData(birthtimes);

	/// we need the parameters for the simulator that randomly drops new pointsources into the environment.
	while (getline(input,line)) {
		if (line == "RANDOM DROP SIMULATOR") {   // reading parameters for the environment simulator
			// first we need to add the position of the ...
			this->hasEnvironmentSimulator = true;
			TVectorData<double> *lastposition = new TVectorData<double> ("last_pointsource_position","tvector_double");
			lastposition->reserveSize(3);
			lastposition->at(0) = 0; lastposition->at(1) = 0; lastposition->at(2) = 0;
			db->addData(lastposition);
			// add time of next drop event to environment.
			DoubleData *tone = new DoubleData("environment_time_of_next_drop", 0);
			db->addData(tone);
			while (getline(input, line) && line != "END") {
				if (line.substr(0,1)!="#" && line != "") {
					iss.clear();
					iss.str(line);
					/// parameters are read as follows from the file:
					/// timpe_parameter, space_parameter, mean_of_pointsource_initial_dist, sigma_of_....
					/// diff
					double	tp, sp, mi, sigma, diff;
					iss >> tp; iss >> sp; iss >> mi; iss >> sigma; iss >> diff;
					DoubleData *d1 = new DoubleData("environment_time_parameter",tp);
					db->addData(d1);
					DoubleData *d2 = new DoubleData("environment_space_parameter", sp);
					db->addData(d2);
					DoubleData *d3 = new DoubleData("mean_of_pointsource_initial_distribution", mi);
					db->addData(d3);
					DoubleData *d4 = new DoubleData("sigma_of_pointsource_initial_distribution", sigma);
					db->addData(d4);
					DoubleData *d5 = new DoubleData("diffusion_coeff_ligand", diff);
					db->addData(d5);
				}
			}
		}else if (line == "TYPE") {
Ejemplo n.º 3
0
Agent* BlindAgentFactory::createAgent()
{
	//Create the agent and the Database
	Agent *bond = new Agent();
	Hive::Database *db = bond->getDatabase();

	// //////////////////////////////////////////////////////////////////
	// Create the base Data objects that are needed by the blind agent
	/////////////////////////////////////////////////////////////////////

	// type name
	StringData *mytypename = new StringData("mytypename", "hans");
	db->addData(mytypename->getName(), mytypename);

	// Internal clock
	DoubleData *celltime = new DoubleData("celltime", 0.0);
	db->addData(celltime->getName(), celltime);

	// record the last dt
	DoubleData *dt = new DoubleData("dt", 0);
	db->addData(dt);

	DoubleData *noutt = new DoubleData("nextOutputTime", 0.0);
	db->addData(noutt->getName(), noutt);

	// Equilibration Time  used by chemotaxis model
	DoubleData *eqtime = new DoubleData("eqtime", cpi->getEqTime());
	db->addData(eqtime->getName(), eqtime);

	// Output frequency of data from the cell may or may not be used
	DoubleData *outputinterval_Data = new DoubleData("outputinterval",this->output_interval);
	db->addData(outputinterval_Data->getName(), outputinterval_Data);

	// at the present the world as well as the metabolism simulatots can only handle one ligand profile
	TVectorData<double> *ligands = new TVectorData<double> ("ligands","tvector_double");
	ligands->reserveSize(1);
	ligands->at(0) = 0;
	db->addData(ligands->getName(),ligands);

	// this stores how much  nutrient a cell would like to get from the world
	TVectorData<double> *appetite = new TVectorData<double> ("appetite", "tvector_double");
	appetite->reserveSize(1);
	appetite->at(0) = 0;
	db->addData(appetite->getName(), appetite);


	// parameter that sets the base effeciency at which nutrient is removed and added to energy
	DoubleData *effeciency = new DoubleData("base_effeciency_of_conversion", 1);
	db->addData(effeciency);

	DoubleData *r1 = new DoubleData("r1", 1);
	db->addData(r1);

	// Marker of the generation of the cell
	IntegerData *generationData = new IntegerData("generation",0);
	db->addData(generationData);


	/// flag that will be set by the death simulator, if the cell has to die
	BoolData *death_flag = new BoolData("death_flag", false);
	db->addData(death_flag->getName(), death_flag);

	/// flag that will be set by the birth simulator, if the cell gives rise to offspring
	BoolData *birth_flag = new BoolData("birth_flag", false);
	db->addData(birth_flag->getName(), birth_flag);

	// UPDATED METABOLISM / BIRTH / DEATH SIMULATOR
	// starting or default values, same for all cells
	double starting_essence = 0.5;
	double default_kcat = 5;
	double default_Km   = 0.1;
	double default_essence_cost_for_movement = 0.025;
	double default_mass_threshold_for_birth = 1;
	double default_essence_threshold_for_death = 0.000001;
	double default_background_death_rate_per_unit_time = 0; // not sure whether it is a good idea to have this in the cell.
    double default_yield = 1;
    bool   default_is_levy = false;
    double default_parameter_for_steplength_dist = 1;
    double default_rho = 0.3;
    double default_velocity = 2;
    double default_current_angle = 2.0;
    double default_distance_desired_to_travel = 0.0;
    double default_traveled_distance = 0.0;

	// create the data items storing these parameters
	DoubleData *essence = new DoubleData("essence",starting_essence);
	// kcat and Km are the rescaled variables
	DoubleData *kcat = new DoubleData("kcat",default_kcat);
	DoubleData *Km = new DoubleData("Km",default_Km);
	// this is the parameter alpha
	DoubleData *essence_cost_for_movement = new DoubleData("essence_cost_for_movement",default_essence_cost_for_movement);
	DoubleData *background_death_rate_per_unit_time = new DoubleData("background_death_rate_per_unit_time",default_background_death_rate_per_unit_time);
	// the user will not be able to set the birth threshold it  is always equal to one
	DoubleData *essence_threshold_for_birth = new DoubleData("essence_threshold_for_birth",default_mass_threshold_for_birth);
	DoubleData *essence_threshold_for_death = new DoubleData("essence_threshold_for_death",default_essence_threshold_for_death);
	DoubleData *velocity = new DoubleData("velocity",default_velocity);
	DoubleData *yield = new DoubleData("yield", default_yield);
	BoolData   *is_levy = new BoolData("is_levy", default_is_levy);
	DoubleData *rho = new DoubleData("rho", default_rho);
	DoubleData *parameter_for_steplength_dist =new DoubleData("parameter_for_steplength_dist", default_parameter_for_steplength_dist);

	// variables needed for the movement simulator to operate correctly
	DoubleData *current_angle = new DoubleData("current_angle", default_current_angle);
	DoubleData *distance_desired_to_travel = new DoubleData("distance_desired_to_travel", default_distance_desired_to_travel);
	DoubleData *traveled_distance = new DoubleData("traveled_distance", default_traveled_distance);

	// add the data items to the database
	db->addData(essence);
	db->addData(kcat);
	db->addData(Km);
	db->addData(essence_cost_for_movement);
	db->addData(background_death_rate_per_unit_time);
	db->addData(essence_threshold_for_birth);
	db->addData(essence_threshold_for_death);
	db->addData(velocity);
	db->addData(yield);
	db->addData(current_angle);
	db->addData(distance_desired_to_travel);
	db->addData(traveled_distance);
	db->addData(is_levy);
	db->addData(rho);
	db->addData(parameter_for_steplength_dist);


	this->cpi->setNextCellParameters(bond);



	// ///////////////////////////////////////////////////////////////////
	// add simulators to agent
	//////////////////////////////////////////////////////////////////////
	this->addSimulatorToAgent(bond);

	//////////////////////////////////////////////////////////////////////
	// add actions to agents action set
	//////////////////////////////////////////////////////////////////////
	this->addActionsToAgentsActionSet(bond);

	//////////////////////////////////////////////////////////////////////
	// add message generators to action set
	//////////////////////////////////////////////////////////////////////
	this->addMessageGeneratorsToAgent(bond);


	return bond;
}