예제 #1
0
파일: tlbr.cpp 프로젝트: BHIVE/BHIVE
MoleculeType * NFtest_tlbr::createL(System * s, int count)
{
	vector <string> compName;
	vector <string> defaultCompState;
	vector < vector <string> > possibleCompStates;

	compName.push_back("r0");
	defaultCompState.push_back("No State");
	vector <string> possibleR0states;
	possibleCompStates.push_back(possibleR0states);

	compName.push_back("r1");
	defaultCompState.push_back("No State");
	vector <string> possibleR1states;
	possibleCompStates.push_back(possibleR1states);

	compName.push_back("r2");
	defaultCompState.push_back("No State");
	vector <string> possibleR2states;
	possibleCompStates.push_back(possibleR2states);

	MoleculeType *L = new MoleculeType("L", compName, defaultCompState, possibleCompStates, s);
	L->populateWithDefaultMolecules(count);
	return L;
}
예제 #2
0
파일: tlbr.cpp 프로젝트: BHIVE/BHIVE
MoleculeType * NFtest_tlbr::createR(System * s, int count)
{
	vector <string> compName;
	vector <string> defaultCompState;
	vector < vector <string> > possibleCompStates;

	compName.push_back("l0");
	defaultCompState.push_back("No State");
	vector <string> possibleL0states;
	possibleCompStates.push_back(possibleL0states);

	compName.push_back("l1");
	defaultCompState.push_back("No State");
	vector <string> possibleL1states;
	possibleCompStates.push_back(possibleL1states);

	MoleculeType *R = new MoleculeType("R", compName, defaultCompState, possibleCompStates, s);
	R->populateWithDefaultMolecules(count);
	return R;
}
예제 #3
0
void NFtest_transcription::run()
{
	cout<<"Running the transcription system"<<endl;




	//  1)
	System *s = new System("Transcription System");


	//  2)
	MoleculeType *molRNA = createRNA(s);


	//  3)  Instantiate the actual molecules (this populate function is the easiest way, but you can do it
	//      manually as well by creating each molecule separately - see the MoleculeType::populate function for
	//      an example on how this can be done).
	molRNA->populateWithDefaultMolecules(500);


	//  4)  Create the reactions and add them to the system.  These are calls to specific functions
	//      below where I set up the details of the reactions.  The numbers are the rates and are in
	//      arbitrary units here.  In general, the rates should be in units of per second.
	ReactionClass * rna_degrade = createReactionRNAdegrades(molRNA, 0.5);
	ReactionClass *rna_transcribe = createReactionRNAtranscribed(molRNA, 100.0);

	s->addReaction(rna_degrade);
	s->addReaction(rna_transcribe);


	//  5)  Add the observables that we want to track throughout the simulation.  Again, to
	//      see how this is done, see the function below.
	addObs(s, molRNA);



	//  6)  Prepare the system for simulation (this adds molecules to reactionLists
	//      and counts up the observables)
	s->prepareForSimulation();
	s->printAllReactions();


	//  7)  Register the output file name (This will put the file in your working directory)
	//      Here, you also want to output the header to the file, which is not done automatically
	//      because you can run a simulation with multiple calls to the sim functions.
	s->registerOutputFileLocation("transcription_system_output.txt");
	s->outputAllObservableNames();




	//8)  Run the simulation!

	//You can optionally equilibrate the system for a set amount of time where output is not
	//recorded (all times are in seconds) using this function where the first parameter is the
	//length of the equilibration, and the second is the number of times we want to print a
	//message that says how we are doing.  After it equilibrates, the simulation time is reset to zero.
	//The first parameter is the number of seconds we want to equilibrate.  The second (optional) parameter
	//is the number of times you want to print an 'ok' output message.  If the second parameter is not
	//given, nothing is outputted to the console.
	s->equilibrate(0,10);

	//There are two ways to run a simulation.  First, you can just call the function sim as in:
	s->sim(50,50);

	//Calling this sim function is the easist way to run a simulation.  The first parameter is the
	//number of seconds you want to run for, the second is the number of times you want to output
	//the results to the outputfile.  So in this example, we run for 500 seconds and output 500 times,
	//so we output once per second.


	//The second way to run a simulation is to call this stepTo function:
	cout<<endl<<endl<<"Calling the stepTo function and stepping to the system time t=600 seconds"<<endl;
	double stoppingTime = s->stepTo(600);
	cout<<"The last reaction was fired at simulation time: "<<stoppingTime<<endl<<endl;

	//This function runs the simulation until the given time is reached, and it also returns the
	//time of the simulation when the last reaction fired (which is now the current time in the
	//system.  This function does not output to a file automatically, so to output using this function,
	//so to get results, you will have to use a call to this function:
	s->outputAllObservableCounts();

	//The stepTo function will have to be written as part of a loop where you decide when it should
	//output.  This gives you more control, but of course requires more work.


	//Here we can print out the list of reactions.  This is nice because it tells us how many times
	//a reaction fired, and how many molecules are in each list at the end of the simulation
	s->printAllReactions();



	//Be nice and clean up when we are done.  Deleting the system (should) delete everything else
	//associated with the system, so we don't ever have to remember to delete individual reactions, molecules
	//moleculeTypes, etc...
	delete s;
}