Beispiel #1
0
/*!
 */
void clearMoleculeComplexIds(System *s) {
	for(int i=0; i<s->getNumOfMoleculeTypes(); i++) {
		MoleculeType *mt = s->getMoleculeType(i);
		for(int j=0; j<mt->getMoleculeCount(); j++) {
			mt->getMolecule(j)->setComplexID(-1);
		}
	}
}
Beispiel #2
0
void DumpSystem::dumpHeaderFile(double dumpTime) {
	string dumpFileName = pathToFolder + s->getName()+"_nf."+Util::toString(dumpTime)+".dump.head";

	//cout<<"writing file: "<<dumpFileName<<endl;;

	ofstream ofs;
	//ios_base::out -- Set for output only, instead of for input/output
	//ios_base::trunc --  Truncate the file - that is overwrite anything that was already there
	ofs.open((dumpFileName).c_str(), ios_base::out | ios_base::trunc);

	//Make sure we could open the stream (this is really the only thing that can go around)
	if(!ofs.is_open()) {
		cout<<"--------"<<endl;
		cout<<"-Error dumping header file.";
		cout<<"-Could not open stream to file: '"<<dumpFileName<<"'"<<endl;
		cout<<"-The path is probably incorrect or does not exist."<<endl;
		return;
	}

	ofs<<"## Automatically generated file from NFsim.  Do not edit manually.\n";
	ofs<<"## To read this file and the associated information, use the\n";
	ofs<<"## included Matlab script readNFdump.m.\n\n";

	ofs<<"\n>> Time #######################################\n";
	ofs<<dumpTime<<"\n";

	ofs<<"\n>> MoleculeTypeDef ############################\n";
	ofs<<"##\tindex\tname\tnumOfInstances\tnumOfComponents\n";
	for(int i=0; i<s->getNumOfMoleculeTypes(); i++) {
		MoleculeType *mt = s->getMoleculeType(i);
		ofs<<"\t"<<i<<"\t"<<mt->getName()<<"\t"<<mt->getMoleculeCount()<<"\t";
		ofs<<mt->getNumOfComponents()<<"\t"<<mt->getNumOfTypeIFunctions()<<"\n";
	}

	ofs<<"\n>> MoleculeTypeComponents #####################\n";
	ofs<<"##\ttype\tindex\tname\n";
	for(int i=0; i<s->getNumOfMoleculeTypes(); i++) {
		MoleculeType *mt = s->getMoleculeType(i);
		for(int k=0; k<mt->getNumOfComponents(); k++) {
			ofs<<"\t"<<i<<"\t"<<k<<"\t"<<mt->getComponentName(k)<<"\n";
		}
	}

	ofs<<"\n>> MoleculeTypeFunctions ######################\n";
	ofs<<"##\ttype\tindex\tname\n";
	for(int i=0; i<s->getNumOfMoleculeTypes(); i++) {
		MoleculeType *mt = s->getMoleculeType(i);
		for(int k=0; k<mt->getNumOfTypeIFunctions(); k++) {
			ofs<<"\t"<<i<<"\t"<<k<<"\t"<<mt->getTypeILocalFunction(k)->getName()<<"\n";
		}
	}

	ofs<<"\n>> EOF ##########################################\n";
	ofs.flush();
	ofs.close();
}
Beispiel #3
0
void DumpSystem::dumpMoleculeTypeFiles(double dumpTime) {

	double complexCount = 0;
	for(int i=0; i<s->getNumOfMoleculeTypes(); i++) {
		MoleculeType *mt = s->getMoleculeType(i);
		string dumpFileName = pathToFolder+s->getName() + "_nf."+Util::toString(dumpTime)+".dump."+Util::toString(i);

		ofstream ofs;

		//ios_base::out -- Set for output only, instead of for input/output
		//ios_base::binary --  Set output to binary
		//ios_base::trunc --  Truncate the file - that is overwrite anything that was already there
		ofs.open((dumpFileName).c_str(), ios_base::out | ios_base::binary | ios_base::trunc);

		//Make sure we could open the stream (this is really the only thing that can go around)
		if(!ofs.is_open()) {
			cout<<"--------"<<endl;
			cout<<"-Error dumping header file.";
			cout<<"-Could not open stream to file: '"<<dumpFileName<<"'"<<endl;
			cout<<"-The path is probably incorrect or does not exist."<<endl;
			return;
		}


		double NOBOND = -1;
		list <Molecule *> molList; list <Molecule *>::iterator molIter;
		for(int j=0; j<mt->getMoleculeCount(); j++) {

			//First, write out this molecules unique ID
			Molecule *m=mt->getMolecule(j);
			double uId = (double)m->getUniqueID();
			ofs.write((char *)&uId,sizeof(double));

			//Second, output the complex number so we can quickly recover
			//the complexes
			if(!s->isUsingComplex()) {
				if(m->getComplexID()==-1) { //if we haven't visited this guy yet...
					m->traverseBondedNeighborhood(molList,ReactionClass::NO_LIMIT);
					for(molIter=molList.begin(); molIter!=molList.end(); molIter++) {
						(*molIter)->setComplexID((int)complexCount);
					}
					ofs.write((char *)&complexCount,sizeof(double));
					complexCount++;
					molList.clear();
				} else {
					double thisUid = m->getComplexID();
					ofs.write((char *)&thisUid,sizeof(double));
				}
			} else {
				complexCount = m->getComplexID();
				ofs.write((char *)&complexCount,sizeof(double));
			}



			//Now export all the components, marking its state and
			//binding partner if any
			for(int k=0; k<mt->getNumOfComponents(); k++) {
				double stateValue = (double)m->getComponentState(k);
				ofs.write((char *)&stateValue,sizeof(double));
				if(!m->isBindingSiteBonded(k)) {
					ofs.write((char *)&NOBOND,sizeof(double));
				} else {
					Molecule *m2=m->getBondedMolecule(k);
					double uId2 = (double)m2->getUniqueID();
					ofs.write((char *)&uId2,sizeof(double));
				}
			}

			for(int k=0; k<mt->getNumOfTypeIFunctions(); k++) {
				double val = m->getLocalFunctionValue(k);
				LocalFunction *lf = m->getLocalFunction(k);
				double localValue = lf->evaluateOn(m,LocalFunction::MOLECULE);
				ofs.write((char *)&val,sizeof(double));
				ofs.write((char *)&localValue,sizeof(double));
			//		ofs<<"\t"<<i<<"\t"<<k<<"\t"<<mt->getTypeIILocalFunction(k)->getName()<<"\n";
			}



		}


		ofs.flush();
		ofs.close();

	}
}
Beispiel #4
0
bool System::saveSpecies(string filename)
{
	bool debugOut = false;

	//open the output filestream
	ofstream speciesFile;
	speciesFile.open(filename.c_str());
	if(!speciesFile.is_open()) {
		cerr<<"Error in System when calling System::saveSpecies(string)!  Cannot open output stream to file "<<filename<<". "<<endl;
		cerr<<"quitting."<<endl;
		exit(1);
	}

	cout<<"\n\nsaving list of final molecular species..."<<endl;

	// create a couple data structures to store results as we go
	list <Molecule *> molecules;
	list <Molecule *>::iterator iter;
	map <int,bool> reportedMolecules;
    map <string,int> reportedSpecies;


	// loop over all the types of molecules that exist
	for( unsigned int k=0; k<allMoleculeTypes.size(); k++)
	{
		// retrieve the MoleculeType
		MoleculeType *mt = allMoleculeTypes.at(k);

		// loop over every individual molecule
		for(int j=0; j<mt->getMoleculeCount(); j++)
		{
			// check if we have looked this molecule before, and skip it if we have
			if(reportedMolecules.find(mt->getMolecule(j)->getUniqueID())!=reportedMolecules.end()) {
				continue;
			}



			//otherwise, we have not visited this particular species before, so loop over the molecules
			//that make up the species
			string speciesString = "";
			molecules.clear();
			mt->getMolecule(j)->traverseBondedNeighborhood(molecules,ReactionClass::NO_LIMIT);

			// key: partnerID1, bsiteID1, partnerID2, bsiteID2
			vector <vector <int> * > bondNumberMap;

			bool isFirst = true;
			for( iter = molecules.begin(); iter != molecules.end(); iter++ )
			{
				Molecule *m = (*iter);
				reportedMolecules.insert(pair <int,bool> (m->getUniqueID(),true));

				//Fist, output the molecule name
				if(isFirst) { speciesString += m->getMoleculeTypeName()+"("; isFirst=false; }
				else { speciesString += "."+m->getMoleculeTypeName()+"("; }

				//Go through each component of the molecule
				for(int s=0; s<m->getMoleculeType()->getNumOfComponents(); s++)
				{
					// output the component name
					string compName = m->getMoleculeType()->getComponentName(s);
					if(m->getMoleculeType()->isEquivalentComponent(s)) {
						// symmetric site, so we need to look up its sym name
						compName = m->getMoleculeType()->getEquivalenceClassComponentNameFromComponentIndex(s);
					}
					if(s==0) speciesString += compName;
					else speciesString += ","+compName;


					//output the state of the component, if it is set
					if(m->getComponentState(s)>=0) {
						speciesString += "~" + m->getMoleculeType()->getComponentStateName(s,m->getComponentState(s));
					}


					// check if the component is bound, if so we have to output a bond
					// we will label the bond incrementally, but we have to check to make
					// sure the bond wasn't declared earlier.  that's what the vector of int vectors is for.
					if(m->isBindingSiteBonded(s)) {
						if(debugOut) cout<<"binding site is bonded"<<endl;
						int partnerID = m->getBondedMolecule(s)->getUniqueID();
						int partnerSite = m->getBondedMoleculeBindingSiteIndex(s);
						int thisBondNumber = -1;

						// create the key
						vector <int> *key = new vector<int>(4);
						if(partnerID<m->getUniqueID()) {
							key->at(0) = partnerID; key->at(1) = partnerSite;
							key->at(2) = m->getUniqueID(); key->at(3)=s;
						} else {
							key->at(2) = partnerID; key->at(3) = partnerSite;
							key->at(0) = m->getUniqueID(); key->at(1)=s;
						}

						//search if that key was already inserted
						bool foundExistingBond = false;
						for(unsigned int bnmIndex =0; bnmIndex < bondNumberMap.size(); bnmIndex++) {
							if( key->at(0)==bondNumberMap.at(bnmIndex)->at(0) &&
								key->at(1)==bondNumberMap.at(bnmIndex)->at(1) &&
							    key->at(2)==bondNumberMap.at(bnmIndex)->at(2) &&
							    key->at(3)==bondNumberMap.at(bnmIndex)->at(3) ) {
								    thisBondNumber = bnmIndex+1;
									foundExistingBond = true;
									if(debugOut) cout<<"Found bond number: "<<thisBondNumber<<endl;
									break;
							}
						}

						//If it was not found, then insert it
						if(!foundExistingBond) {
							bondNumberMap.push_back(key);
							thisBondNumber = bondNumberMap.size();
							if(debugOut) cout<<"Creating bond number: "<<bondNumberMap.size()<<endl;
						}
						speciesString += "!" + NFutil::toString(thisBondNumber);
					}

				}


				speciesString += ")";
			}

			if(reportedSpecies.find(speciesString) != reportedSpecies.end()) {
				reportedSpecies[speciesString] = reportedSpecies[speciesString] + mt->getMolecule(j)->getPopulation();
			} else {
				reportedSpecies.insert(pair <string,int> (speciesString, mt->getMolecule(j)->getPopulation()));
			}

			//speciesString += "  1";
			//cout<<speciesString<<endl;

			if(debugOut) cout<<endl<<endl;

			//delete elements of the map
			while(bondNumberMap.size()>0) {
				vector <int> *v = bondNumberMap.at(bondNumberMap.size()-1);
				bondNumberMap.pop_back();
				delete v;
			}

			if(debugOut) cout<<endl<<endl;

		}
	}


	speciesFile<<"# nfsim generated species list for system: '"<< this->name <<"'\n";
	speciesFile<<"# warning! this feature is not yet fully tested! \n";
	for ( map<string,int>::iterator  it=reportedSpecies.begin() ; it != reportedSpecies.end(); it++ )
		speciesFile << (*it).first << "  " << (*it).second << "\n";
	speciesFile.flush();
	speciesFile.close();
	return true;
}