コード例 #1
0
ファイル: main.py プロジェクト: raphaelshirley/RMG-Py
def execute(inputFile, options):
	"""
	Generate a reaction model for the set of reaction systems specified in an 
	input file at location `inputFile`. Output and temporary files will be 
	placed in the directories `outputDir` and `scratchDir`, respectively; if
	either of these are empty strings, the corresponding files will be placed
	in the same directory as the input file. The `libraryDir` parameter can be
	used to specify additional directories to search for RMG databases. The
	`verbose` parameter is an integer specifying the amount of log text seen
	at the console; the levels correspond to those of the :data:`logging` module.
	"""
	
	# Set directories
	settings.outputDirectory = options.outputDirectory
	settings.scratchDirectory = options.scratchDirectory
	settings.libraryDirectory = options.libraryDirectory

	# Save initialization time
	settings.initializationTime = time.time()

	# Set up log (uses stdout and a file)
	initializeLog(options.verbose)
	
	# Log start timestamp
	logging.info('RMG execution initiated at ' + time.asctime() + '\n')
	
	# Print out RMG header
	printRMGHeader()
	
	# Make output subdirectories
	plotDir = os.path.join(settings.outputDirectory, 'plot')
	if os.path.exists(plotDir):
		for f in os.listdir(plotDir):
			os.remove(plotDir + '/' + f)
		os.rmdir(plotDir)
	os.mkdir(plotDir)

	specDir = os.path.join(settings.outputDirectory, 'species')
	if os.path.exists(specDir):
		for f in os.listdir(specDir):
			os.remove(specDir + '/' + f)
		os.rmdir(specDir)
	os.mkdir(specDir)

	# Read input file
	reactionModel, coreSpecies, reactionSystems = io.readInputFile(inputFile)
	
	# Initialize reaction model
	if options.restart:
		import cPickle
		logging.info('Loading previous restart file...')
		f = open(os.path.join(settings.outputDirectory,'restart.pkl'), 'rb')
		species.speciesList = cPickle.load(f)
		species.speciesCounter = cPickle.load(f)
		reaction.reactionList = cPickle.load(f)
		reactionModel = cPickle.load(f)
		reactionSystems = cPickle.load(f)
		f.close()
		options.restart = False # have already restarted
	else:
		reactionModel.initialize(coreSpecies)

	# RMG execution statistics
	coreSpeciesCount = []
	coreReactionCount = []
	edgeSpeciesCount = []
	edgeReactionCount = []
	execTime = []
	restartSize = []
	memoryUse = []

	# Main RMG loop
	done = False
	while not done:

		done = True
		speciesToAdd = []
		for index, reactionSystem in enumerate(reactionSystems):
			
			# Conduct simulation
			logging.info('Conducting simulation of reaction system %s...' % (index+1))
			t, y, dydt, valid, spec = reactionSystem.simulate(reactionModel)

			# Postprocess results
			logging.info('Saving simulation results for reaction system %s...' % (index+1))
			reactionSystem.postprocess(reactionModel, t, y, dydt, str(index+1))

			# If simulation is invalid, note which species should be added to
			# the core
			if not valid:
				speciesToAdd.append(spec)
				done = False

		# Add the notes species to the core
		speciesToAdd = list(set(speciesToAdd))
		for spec in speciesToAdd:
			reactionModel.enlarge(spec)
		
		# Save the restart file
		import cPickle
		logging.info('Saving restart file...')
		f = open(os.path.join(settings.outputDirectory,'restart.pkl'), 'wb')
		cPickle.dump(species.speciesList, f)
		cPickle.dump(species.speciesCounter, f)
		cPickle.dump(reaction.reactionList, f)
		cPickle.dump(reactionModel, f)
		cPickle.dump(reactionSystems, f)
		f.close()

		if not done:
			logging.info('Updating RMG execution statistics...')
			# Update RMG execution statistics
			coreSpeciesCount.append(len(reactionModel.core.species))
			coreReactionCount.append(len(reactionModel.core.reactions))
			edgeSpeciesCount.append(len(reactionModel.edge.species))
			edgeReactionCount.append(len(reactionModel.edge.reactions))
			execTime.append(time.time() - settings.initializationTime)
			from guppy import hpy
			hp = hpy()
			memoryUse.append(hp.heap().size / 1.0e6)
			logging.debug('Execution time: %s s' % (execTime[-1]))
			logging.debug('Memory used: %s MB' % (memoryUse[-1]))
			restartSize.append(os.path.getsize(os.path.join(settings.outputDirectory,'restart.pkl')) / 1.0e6)
			generateExecutionPlots(execTime, coreSpeciesCount, coreReactionCount, edgeSpeciesCount, edgeReactionCount, memoryUse, restartSize)

		logging.info('')


	# Write output file
	logging.info('MODEL GENERATION COMPLETED')
	logging.info('')
	logging.info('The final model core has %s species and %s reactions' % (len(reactionModel.core.species), len(reactionModel.core.reactions)))
	logging.info('The final model edge has %s species and %s reactions' % (len(reactionModel.edge.species), len(reactionModel.edge.reactions)))
	io.writeOutputFile(os.path.join(settings.outputDirectory,'output.xml'), reactionModel, reactionSystems)

	# Log end timestamp
	logging.info('RMG execution terminated at ' + time.asctime())
コード例 #2
0
ファイル: main.py プロジェクト: athlonshi/RMG-Py
		logging.info('')
		
		# Consider stopping gracefully if the next iteration might take us
		# past the wall time
		if settings.wallTime > 0 and len(execTime) > 1:
			t = execTime[-1]
			dt = execTime[-1] - execTime[-2]
			if t + 2 * dt > settings.wallTime:
				logging.info('MODEL GENERATION TERMINATED')
				logging.info('')
				logging.info('There is not enough time to complete the next iteration before the wall time is reached.')
				logging.info('The output model may be incomplete.')
				logging.info('')
				logging.info('The current model core has %s species and %s reactions' % (len(reactionModel.core.species), len(reactionModel.core.reactions)))
				logging.info('The current model edge has %s species and %s reactions' % (len(reactionModel.edge.species), len(reactionModel.edge.reactions)))
				io.writeOutputFile(os.path.join(settings.outputDirectory,'output.xml'), reactionModel, reactionSystems)
				return

	# Write output file
	logging.info('MODEL GENERATION COMPLETED')
	logging.info('')
	logging.info('The final model core has %s species and %s reactions' % (len(reactionModel.core.species), len(reactionModel.core.reactions)))
	logging.info('The final model edge has %s species and %s reactions' % (len(reactionModel.edge.species), len(reactionModel.edge.reactions)))
	io.writeOutputFile(os.path.join(settings.outputDirectory,'output.xml'), reactionModel, reactionSystems)

	# Log end timestamp
	logging.info('')
	logging.info('RMG execution terminated at ' + time.asctime())
	
################################################################################