Agent* BugFactory::createAgent() {
// create agent and get his database
Agent *bond = new Agent();
Database *db = bond->getDatabase();
// --- fill database with data ---
// time of bug
DoubleData *bugtime = new DoubleData("bug_time",0.0);
db->addData(bugtime);
// dt
DoubleData *dt = new DoubleData("dt",1.0);
db->addData(dt);
// PythonProgram
StringData *pythonProgram = new StringData("pythonProgram",this->program);
db->addData(pythonProgram);
// temperature which the agent prefers to have
DoubleData *pt = new DoubleData("preferred_temperature",3.0);
db->addData(pt);
// output interval
DoubleData *oi = new DoubleData("output_interval", this->output_interval);
db->addData(oi);
// next output time
DoubleData *noti = new DoubleData("next_output_time", 0);
db->addData(noti);
// vector in which the agent stores the temperatures in its local vivicinity
TVectorData<DoubleData> *vec = new TVectorData<DoubleData> ("local_temperature_around_me", "tvector_doubledata");
vec->reserveSize(5);
db->addData(vec);
// rate with which the bug produces heat
DoubleData *heat_rate = new DoubleData("heat_rate",1.0);
db->addData(heat_rate);
// direction in which the bug desires to move
IntegerData *move_direction = new IntegerData("move_direction", 0);
db->addData(move_direction);
/// finally add actions, simulators, and message generators to the bug
this->addActionsToAgentsActionSet(bond);
this->addSimulatorToAgent(bond);
this->addMessageGeneratorsToAgent(bond);
// return agent
return bond;
}
Creator::Creator()
{
//composing the world hierarchy(i havent figured out the composer yet)
WorldFactory *WF = new WorldFactory();
Agent *W = WF->createAgent();
BacteriumFactory *BF = new BacteriumFactory();
Agent *B = BF->createAgent();
W->addChild(B->getAgentId());
B->setParent(W->getAgentId());
//dvorak could do better, I suppose
//initializing the position, ligand_level,ligand and phosphorylation level
srand(time(NULL));
int position = rand()%3;
int ligand_level = rand()%3;
double phosph = 0;
double ligand;
switch (ligand_level) {
case 0: ligand = 10; break;
case 1: ligand = 1000; break;
case 2: ligand = 100000; break;
}
cout << endl<<endl<<endl;
cout << "Bacterium is in box "<<position<<endl;
cout << "The ligand level is "<<ligand_level<<endl;
cout << "The ligand conc is "<<ligand<<endl;
cout << "The phosph conc is "<<phosph <<endl;
//Initializing the Databases
IntegerData *data1 = new IntegerData("Ligand Level",ligand_level);
DoubleData *data2 = new DoubleData("Phosph Conc", phosph);
W->getDatabase()->addData(data1->getName(),data1);
W->getDatabase()->addData(data2->getName(),data2);
DoubleData *data3 = new DoubleData("Ligand Conc",ligand);
DoubleData *data4 = new DoubleData("Phosph Conc", phosph);
B->getDatabase()->addData(data3->getName(),data3);
B->getDatabase()->addData(data4->getName(),data4);
}
void SimpleCellDefaultParallelComposer::outputNow(double currentTime)
{
// output format:
// cellNumber, time, cellState, CheYp, motState[0], x,y,z
//Create all of the SimpleCells
for(unsigned int k=1; k<orchestra.size(); k++) {
Agent *cellAgent = orchestra.at(k);
Database *db = cellAgent->getDatabase();
// cellNumber
double kDouble = (double)k;
outputFile.write((char *)&kDouble,sizeof(double));
// time
outputFile.write((char *)¤tTime,sizeof(double));
//cell state
double cellState = (double)((IntegerData *)db->getDataItem("CurrentCellState"))->getInteger();
outputFile.write((char *)&cellState, sizeof(double));
//cheYp
double ypConc = ((DoubleVectorData *)db->getDataItem("CheYp"))->getDouble(0);
outputFile.write((char *)&ypConc, sizeof(double));
//cheYp
double motState = (double)((IntVectorData *)db->getDataItem("MotorStates"))->getInt(0);
outputFile.write((char *)&motState, sizeof(double));
DoubleVectorData *curPos = ((DoubleVectorData *)db->getDataItem("Position"));
double x = curPos->getDouble(1);
double y = curPos->getDouble(2);
double z = curPos->getDouble(3);
outputFile.write((char *)&x, sizeof(double));
outputFile.write((char *)&y, sizeof(double));
outputFile.write((char *)&z, sizeof(double));
double lig = ((DoubleVectorData *)db->getDataItem("Chemical"))->getDouble(0);
outputFile.write((char *)&lig, sizeof(double));
}
}
Agent *UniverseFactory::createAgent() {
Agent *a = new Agent();
GenerateUniverseMessageToWorld* msgGen = new GenerateUniverseMessageToWorld(a);
a->addMessageGenerator(msgGen);
GenerateUniverseFluxMessageToWorld* msgGenTwo = new GenerateUniverseFluxMessageToWorld(a);
a->addMessageGenerator(msgGenTwo);
UniverseDatabase* universityDB = new UniverseDatabase();
a->getDatabase()->addData("univ", universityDB);
addSimulatorToAgent(a);
SyncWorldToUniverse* universeAction = new SyncWorldToUniverse();
a->addAction(universeAction);
RecvFluxMessageFromWorld* fluxAction = new RecvFluxMessageFromWorld();
a->addAction(fluxAction);
return a;
};
Agent* OutputAgentFactory::createAgent() {
// create new output agent
Agent *shakespeare = new Agent();
Database *db = shakespeare->getDatabase();
// add number of bugs and length of output interval to shakespeare's database
IntegerData *nb = new IntegerData("number_bugs",number_bugs);
db->addData(nb);
DoubleData *oi = new DoubleData("output_interval", output_interval);
db->addData(oi);
// we just need to add the actions to the agents.
// the output-agent does not possess any message generators or simulators.
this->addActionsToAgentsActionSet(shakespeare);
return shakespeare;
}
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") {
Agent* WorldAgentFactoryII::createAgent() {
cerr << "# creating worldagent" << endl;
// create world agent and get his database
Agent *world = new Agent();
Hive::Database *db = world->getDatabase();
/// this value will be overwritten by the parser if we read cell positions
IntegerData *numberofcells = new IntegerData("numberofcells", this->numbercells);
db->addData(numberofcells->getName(), numberofcells);
// DATA FOR OUTPUT ... this is passed via the command line
DoubleData *output_interval = new DoubleData("output_interval",this->output_interval);
db->addData(output_interval->getName(), output_interval);
// set up agent by using a parser
// open the relevant inputstream
ifstream input(this->inputname.c_str());
// set up parser; GWA = Garrit's World Agent
GWAParser gwap;
cerr << "# starting to invoke GWAParser for parsing the environment" << endl;
cerr << "# reading from file: '" << this->inputname <<"'"<< endl;
gwap.setInputfile(input);
gwap.setAgent(world);
gwap.parse();
this->equilibration_time = gwap.getEquilibrationTime();
cerr << "# done parsing input file" << endl;
// get some information from the database
// first the cell number such that the registrar can be initialised correctly
this->numbercells = ((IntegerData*) db->getDataItem("numberofcells"))->getInteger();
// set the timestep for initialising the simulators
this->dt = ((DoubleData*) db->getDataItem("dt"))->getDouble();
// ------------------ Data Structures for the registrar --------------------------------
// 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);
}
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);
/// now we add the remaining things to the world agent
/// add simulators to agent
this->addSimulatorToAgent(world);
cerr << "# added simulators to the world agent" << endl;
/// add actions to agents action set
this->addActionsToAgentsActionSet(world);
cerr << "# added actions to the world agent" << endl;
/// add message generators to action set
this->addMessageGeneratorsToAgent(world);
cerr << "# added message generators to the world agent" << endl;
cerr<<"# done creating world"<<endl;
return world;
}
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") {
Agent* WorldFactory::createAgent() {
// create the agent and get its datbase
Agent *bond = new Agent();
Database *db = bond->getDatabase();
Py_Initialize();
// create the data items that are needed for this agent and add
// the data items to the agent's database
// clock
DoubleData *celltime = new DoubleData("worldtime", 0.0);
db->addData(celltime);
// time interval
DoubleData *dt = new DoubleData("dt",0.1);
db->addData(dt);
// output interval
DoubleData *oi = new DoubleData("output_interval", this->output_interval);
db->addData(oi);
DoubleData *noti = new DoubleData("next_output_time", this->output_interval);
db->addData(noti);
// diffusion coefficient
DoubleData *diff = new DoubleData("diffusion_coeff", 0.25);
db->addData(diff);
// dissipation rate
DoubleData *dis = new DoubleData("dissipation_rate", 0.1);
db->addData(dis);
// size of the grids in the system. all grids will be quadratic.
int grid_size = 100;
IntegerData *gs = new IntegerData("grid_size", grid_size);
db->addData(gs);
// number_bugs
IntegerData *bn = new IntegerData("number_bugs", number_bugs);
db->addData(bn);
int i_number_of_elements = 4;
IntegerData *number_of_elements = new IntegerData("number_of_elements",i_number_of_elements);
db->addData(number_of_elements);
// elemetNames
TVectorData<StringData> *element_names = new TVectorData<StringData>("element_names","tvectordata_string");
element_names->reserveSize(4);
string elements[] = {"A", "B", "C", "D"};
float coeffs[]={0.1,0.2,0.3,0.4};
float diss[]={0.4,0.3,0.2,0.1};
for(int a=0; a<i_number_of_elements; a++){
element_names->at(a).setString(elements[a]);
// diffusion coefficient
cout<<"diffusion_"+elements[a]+"_coeff"<<" "<<coeffs[a]<<endl;
DoubleData *diff = new DoubleData("diffusion_"+elements[a]+"_coeff"+elements[a],coeffs[a]);
db->addData(diff);
// dissipation rate
DoubleData *dis = new DoubleData("dissipation_"+elements[a]+"_rate"+elements[a],diss[a]);
db->addData(dis);
TVectorData<TVectorData<DoubleData>* > *element_grid;
element_grid = new TVectorData<TVectorData<DoubleData>* >("element_"+elements[a]+"_grid","tvectordata_double");
cout<<"element_"+elements[a]+"_grid"<<endl;
element_grid->reserveSize(grid_size);
for (int i=0; i<grid_size; i++) {
element_grid->at(i) = new TVectorData<DoubleData>("grid_row", "tvectordata_double");
element_grid->at(i)->reserveSize(grid_size);
/// initialise the temperature to zero.
for (int j=0; j<grid_size; j++)
element_grid->at(i)->at(j).setDouble(0);
}
// add data to agent's database
db->addData(element_grid);
}
db->addData(element_names);
// temperature grid.
TVectorData<TVectorData<DoubleData>* > *temperature_grid = new TVectorData<TVectorData<DoubleData>* >("temperature_grid","tvectordata_double");
temperature_grid->reserveSize(grid_size);
for (int i=0; i<grid_size; i++) {
temperature_grid->at(i) = new TVectorData<DoubleData>("grid_row", "tvectordata_double");
temperature_grid->at(i)->reserveSize(grid_size);
/// initialise the temperature to zero.
for (int j=0; j<grid_size; j++)
temperature_grid->at(i)->at(j).setDouble(0);
}
// add data to agent's database
db->addData(temperature_grid);
// bug grid: bug_grid[i][j] returns the id of the bug-agent that is lives on grid position i,j.
// if position i/j is empty, bug_grid[i][j] returns zero
TVectorData<TVectorData<IntegerData>* > *bug_grid = new TVectorData<TVectorData<IntegerData>* >("bug_grid", "tvectordata_int");
bug_grid->reserveSize(grid_size);
for (int i=0; i<grid_size; i++) {
// the name of this data item will not be used
bug_grid->at(i) = new TVectorData<IntegerData>("grid_row","tvectordata_int");
bug_grid->at(i)->reserveSize(grid_size);
/// initialise the temperature to zero.
for (int j=0; j<grid_size; j++)
bug_grid->at(i)->at(j).setInteger(0);
}
// add data to agent's database
db->addData(bug_grid);
// bug-positions. vector storing the x and y index of where bug i lives.
TVectorData<TVectorData<IntegerData>* > *bug_positions = new TVectorData<TVectorData<IntegerData>* >("bug_positions", "tvectordata_int");
bug_positions->reserveSize(number_bugs);
// reserve size
for (int i=0; i<number_bugs; i++) {
bug_positions->at(i) = new TVectorData<IntegerData> ("bug_position", "tvectordata_int");
bug_positions->at(i)->reserveSize(2);
}
// add data to agent's database
db->addData(bug_positions);
// temporary matrix storing the desired bug positions.
TVectorData<TVectorData<TVectorData<IntegerData>* >* > *desired_bug_grid = new TVectorData<TVectorData<TVectorData<IntegerData>* >* > ("desired_bug_grid", "no_type_given");
desired_bug_grid->reserveSize(grid_size);
for (int i=0; i<grid_size; i++) {
desired_bug_grid->at(i) = new TVectorData<TVectorData<IntegerData>* >("grid_row", "no_type_given");
desired_bug_grid->at(i)->reserveSize(grid_size);
for (int j=0; j<grid_size; j++)
desired_bug_grid->at(i)->at(j) = new TVectorData<IntegerData> ("no_name_given", "no_type_given");
}
db->addData(desired_bug_grid);
// vector for temporary storage
TVectorData<TVectorData<IntegerData>* > *desired_bug_positions = new TVectorData<TVectorData<IntegerData>* >("desired_bug_positions", "tvectordata_int");
desired_bug_positions->reserveSize(number_bugs);
for (int i=0; i<number_bugs; i++) {
desired_bug_positions->at(i) = new TVectorData<IntegerData> ("bug_position", "tvectordata_int");
desired_bug_positions->at(i)->reserveSize(2);
}
db->addData(desired_bug_positions);
// we will randomly initialise the positions of the bugs here. in general, it would be a lot nicer to have
// an initialiser class with which one could choose between different initialisation methods. however, since this
// is only an example on how to do agent/rule-based simulations in the hive, i do not want to spend too much time
// implementing this. hence i do it this way!
int x,y;
for (int i=0; i<number_bugs; i++) {
// randomly select a position
do {
x = Util::RANDOM_INT(0,99);
y = Util::RANDOM_INT(0,99);
} while (bug_grid->at(x)->at(y).getInteger() != 0);
// update bug_grid
bug_grid->at(x)->at(y).setInteger(i+1);
// update bug_positions
bug_positions->at(i)->at(0).setInteger(x);
bug_positions->at(i)->at(1).setInteger(y);
}
// finally add actions, simulators and message generators to the world agent
this->addActionsToAgentsActionSet(bond);
this->addSimulatorToAgent(bond);
this->addMessageGeneratorsToAgent(bond);
return bond;
}
void BlindAgentNotifyWorldThatNewAgentIsBorn::placeMessage(int destID) {
//check if I have to give birth or not
if(birthFlag->getBool())
{
birthFlag->setBool(false);
// if the death simulator determined death, then do not create the birth message
if(deathFlag->getBool()) return;
//get the agentfactory, and use it to create an agent
AgentFactory *af = Registrar::getSystemRegistrar()->getAgentFactory(1);
Agent *a = af->createAgent();
// has the same parent
// NOTE: the parent is the top level agent in the hierarchy of agents,
// not the agent that gave birth!
a->setParent(source->getParentId());
// has the same special agents
for(unsigned int s=0; s<source->getNumOfSpecialAgents(); s++)
a->addSpecialAgent(source->getSpecialAgentId(s));
// needs the same communicator, of course, of course
a->addCommunicator(source->getCommunicator());
// set the other properties of agent 'a' based on the source exactly...
a->copyDatabaseInformationFromExistingAgent(this->source);
// CLEARLY A HACK!! CHANGE THIS AT SOME POINT TO DUPLICATE SIMULATORS
// replace the movement simulator with the correct one
if (((BoolData*) a->getDatabase()->getDataItem("is_levy"))->getBool()) {
LevyRunLengthSimulator *levy = new LevyRunLengthSimulator();
a->replaceSimulator(0,levy);
} else {
ExponentialRunLengthSimulator *expo = new ExponentialRunLengthSimulator();
a->replaceSimulator(0,expo);
}
// ANOTHER HACK !! TIME TO NEXT OUTPUT IS OFF WHEN WE GET HERE, SO WE MUST UPDATE
DoubleData *t = (DoubleData *) a->getDatabase()->getDataItem("celltime");
//DoubleData *oi = (DoubleData *) a->getDatabase()->getDataItem("outputinterval");
//DoubleData *no = (DoubleData*) a->getDatabase()->getDataItem("nextOutputTime");
DoubleData *dt = (DoubleData *) a->getDatabase()->getDataItem("dt");
t->setDouble(t->getDouble()-dt->getDouble());
//register agent a
Message *specialMssg = new Message();
specialMssg->setAction(ChemoPopActionIDs::SPECIAL_AGENT_UPDATE_BLIND_AGENT_COUNT_ACTION_ID);
specialMssg->setArgument(new IntegerData("ChangeInBlindAgentNumber",1));
Registrar::getSystemRegistrar()->registerNewAgentAndSendMessageToSpecialAgent(a,specialMssg);
// Now, send the message to the world!!
Message *msg = new Message();
msg->setAction(ChemoPopActionIDs::UPDATE_WORLD_BLIND_AGENT_BIRTH_ACTION_ID);
msg->setDestinationID(destID);
//pass my agentID (the mother) and the new agent ID (the baby)
TVectorData<int> *info = new TVectorData<int>("new_cell_info","tvectordata_int");
info->addElementToEnd(this->source->getAgentId());
info->addElementToEnd(a->getAgentId()); // get new AgentID !!!
msg->setArgument(info);
source->placeMessageInOutbox(msg);
}
}
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;
}
