def prepare(self):
if isinstance(self.mesher, str):
mesher = UtilityRunner(
argv=[self.mesher, "-case", self.dire.name],
silent=True,
logname=self.mesher,
)
mesher.start()
if not mesher.data["OK"]:
raise RuntimeError("Failed running mesher")
else:
for mesher_step in self.mesher:
mesher = UtilityRunner(
argv=[mesher_step, "-case", self.dire.name],
silent=True,
logname=mesher_step,
)
mesher.start()
if not mesher.data["OK"]:
raise RuntimeError(f"Failed running mesher {mesher_step}")
if self.np != 1:
decomposer = UtilityRunner(
argv=["decomposePar", "-case", self.dire.name],
silent=True,
logname="decomposePar",
)
decomposer.start()
if not decomposer.data["OK"]:
raise RuntimeError("Failed decomposing case")
def RunUtilities(self, sense='single'):
# Get the pressure difference (Using an external utility)
pUtil = UtilityRunner(
argv=[self.pCmd, "-case", self.case_path, "-latestTime"],
silent=True,
logname="Pressure")
pUtil.add("PressureDifference",
"Pressure drop = (%f%) between inlet and outlet",
idNr=1)
pUtil.start()
deltaP = UtilityRunner.get(pUtil, "PressureDifference")[0]
tUtil = UtilityRunner(
argv=[self.tCmd, "-case", self.case_path, "-latestTime"],
silent=True,
logname="Temperature")
tUtil.add("TemperatureDifference",
"Temperature drop = (%f%) between inlet and outlet",
idNr=1)
tUtil.start()
deltaT = UtilityRunner.get(tUtil, "TemperatureDifference")[0]
if sense == "multi":
return float(deltaT), float(deltaP)
else:
return float(deltaT)
def RunUtilities(self, sense='single'):
# Get the pressure difference (Using an external utility)
pUtil = UtilityRunner(
argv=[self.pCmd, "-case", self.case_path, "-latestTime"],
silent=True,
logname="Pressure")
pUtil.add("PressureDifference",
"Pressure drop = (%f%) between inlet and outlet",
idNr=1)
pUtil.start()
deltaP = UtilityRunner.get(pUtil, "PressureDifference")[0]
if sense == "multi":
# Get the mass flow (Using an external utility)
mUtil = UtilityRunner(
argv=[self.mCmd, "-case", self.case_path, "-latestTime"],
silent=True,
logname="MassFlow")
mUtil.add("mass", "Flux at outlet = (%f%)", idNr=1)
mUtil.start()
massFlow = UtilityRunner.get(mUtil, "mass")[0]
return float(deltaP), float(massFlow)
else:
return float(deltaP)
def execute(self, para, log):
argv = [self.utility, ".", para['case']] + self.options.split()
print_(" Executing and analyzing", " ".join(argv), end=" ")
sys.stdout.flush()
run = UtilityRunner(argv,
silent=True,
lam=Command.parallel,
logname="_".join(argv))
run.add("data", self.regexp)
run.start()
data = run.analyzer.getData("data")
result = None
if data != None:
result = []
for a in data:
result.append(a)
if result == None:
print_("no data", end=" ")
else:
print_(result, end=" ")
if run.runOK():
print_()
else:
print_("---> there was a problem")
return run.runOK(), result
def RunUtilities():
current = os.getcwd()
solver1 = "icoUncoupledKinematicCustomInteractionFoam"
# run parcelFoam for one timestep:
mCalculated = UtilityRunner(argv=[solver1, "-case", current],
silent=True,
logname="ParticleEscape")
print(
"RunUtilities(x): icoUncoupledKinematicCustomInteractionFoam run for 1 timestep"
)
mCalculated.add("massEscape",
"- escape = outflow_top = (%f%)",
idNr=1)
mCalculated.add("massIntroduced",
"- mass introduced = (%f%)",
idNr=1)
mCalculated.start()
massEscape1 = UtilityRunner.get(mCalculated, "massEscape")[0]
print("RunUtilities(): read massEscape to a number", str(massEscape1))
massIntro1 = UtilityRunner.get(mCalculated, "massIntroduced")[0]
print("RunUtilities(): read massIntroduced to a number", str(massIntro1))
if ((platform == 'isambard_test') or (platform == 'isca_test')):
subprocess.call(['rm', '-rf', current + '/0.011'])
print("RunUtilities(): removed 0.011 directory")
# remove redundant files
subprocess.call([
'pyFoamClearCase.py', current, '--after=0.01',
'--processors-remove'
])
subprocess.call(['rm', '-rf', current + '/0'])
print("RunUtilities(): removed processor directories and 0 directory")
else:
subprocess.call(['rm', '-rf', current + '/262.001'])
print("RunUtilities(): removed 262.001 directory")
# remove redundant files
subprocess.call([
'pyFoamClearCase.py', current, '--after=262', '--processors-remove'
])
subprocess.call(['rm', '-rf', current + '/0'])
print("RunUtilities(): removed processor directories and 0 directory")
with open(current + "/efficiency.txt", "a") as myfile_efficiency:
myfile_efficiency.write(
str((float(massIntro1) - float(massEscape1)) / float(massIntro1)) +
'\n')
print("RunUtilities(): written efficiency to a file")
def runApp(self, app, args={}, quiet=False):
''' Run an application with the specified arguments '''
quiet_options = {
'silent': True if quiet else False,
}
cmd = [app, '-case', self._path]
cmd += sum([['-{}'.format(k), v] for k, v in args.items()], [])
return UtilityRunner(cmd, **quiet_options).start()
def RunUtilities(self, sense='single'):
lines = []
lines2 = []
if os.path.isdir(self.case_path + "10000"):
N = 1000
else:
N = 1
subprocess.call(
['pyFoamCopyLastToFirst.py', self.case_path, self.case_path])
subprocess.call([
'pyFoamClearCase.py', self.case_path, '--processors-remove',
'--keep-postprocessing'
])
# Get the pressure difference (Using an external utility)
pUtil = UtilityRunner(
argv=[self.pCmd, "-case", self.case_path, "-latestTime"],
silent=True,
logname="Pressure")
pUtil.add("PressureDifference",
"Pressure drop = (%f%) between inlet and outlet",
idNr=1)
pUtil.start()
deltaP = UtilityRunner.get(pUtil, "PressureDifference")[0]
if sense == "multi":
# Get the mass flow (Using an external utility)
mUtil = UtilityRunner(
argv=[self.mCmd, "-case", self.case_path, "-latestTime"],
silent=True,
logname="MassFlow")
mUtil.add("mass", "Flux at outlet = (%f%)", idNr=1)
mUtil.start()
massFlow = UtilityRunner.get(mUtil, "mass")[0]
return -float(deltaP), -float(massFlow)
else:
return -float(deltaP)
def setUp(self):
self.dest = mktemp()
SolutionDirectory(damBreakTutorial(), archive=None,
paraviewLink=False).cloneCase(self.dest)
if oldApp():
pathSpec = [path.dirname(self.dest), path.basename(self.dest)]
else:
pathSpec = ["-case", self.dest]
run = UtilityRunner(argv=["blockMesh"] + pathSpec,
silent=False,
server=False)
run.start()
def run(self):
if self.opts.regexp == None:
self.parser.error("Regular expression needed")
cName = self.parser.casePath()
run = UtilityRunner(argv=self.parser.getArgs(),
silent=self.opts.silent,
server=True)
for i, r in enumerate(self.opts.regexp):
name = self.opts.name
if len(self.opts.regexp) > 1:
name = "%s_%d" % (name, i)
run.add(name, r)
self.addToCaseLog(cName, "Starting")
run.start()
self.addToCaseLog(cName, "Ending")
allData = run.data
for i, r in enumerate(self.opts.regexp):
name = self.opts.name
if len(self.opts.regexp) > 1:
name = "%s_%d" % (name, i)
fn = path.join(run.getDirname(), name)
data = run.analyzer.getData(name)
allData["analyzed"][name] = data
if data == None:
print_(sys.argv[0] + ": No data found for expression", r)
else:
if self.opts.echo:
fh = open(fn)
print_(fh.read())
fh.close()
else:
print_(sys.argv[0] + ": Output written to file " + fn)
self.setData(allData)
def RunUtilities(self, sense='multi'):
# Get the pressure difference (Using an external utility)
pUtil = UtilityRunner(
argv=[self.pCmd, "-case", self.case_path, "-latestTime"],
silent=True,
logname="Pressure")
pUtil.add("PressureDifference",
"Total pressure drop = (%f%) between Inlet and Outlet1",
idNr=1)
pUtil.add("PressureDifference2",
"Total pressure drop = (%f%) between Inlet and Outlet2",
idNr=1)
pUtil.start()
deltaP = UtilityRunner.get(pUtil, "PressureDifference")[0]
deltaP2 = UtilityRunner.get(pUtil, "PressureDifference2")[0]
if sense == "multi":
return float(deltaP), float(deltaP2)
else:
return max(np.abs(float(deltaP)), np.abs(float(deltaP2))),
def run(self):
cName = self.parser.casePath()
times = self.processTimestepOptions(
SolutionDirectory(cName, archive=None))
if len(times) < 1:
self.warning("Can't continue without time-steps")
return
lam = self.getParallel(SolutionDirectory(cName, archive=None))
data = []
for i, t in enumerate(times):
print_(" Running for t=", t)
run = UtilityRunner(
argv=self.parser.getArgs() + ["-time", t],
silent=self.opts.progress or self.opts.silent,
server=self.opts.server,
logname="%s.%s.t=%s" %
(self.opts.logname, self.parser.getApplication(), t),
compressLog=self.opts.compress,
logTail=self.opts.logTail,
noLog=self.opts.noLog,
echoCommandLine=self.opts.echoCommandPrefix,
lam=lam)
self.addToCaseLog(cName, "Starting for t=%s", t)
run.start()
self.setData({t: run.data})
self.addToCaseLog(cName, "Ending")
self.reportUsage(run)
self.reportRunnerData(run)
data.append(run.data)
return data
def main():
parser = OptionParser(usage=usage, version=version)
parser.add_option("-q",
"--quiet",
action="store_true",
dest="quiet",
default=False,
help="Only print warnings and errors")
parser.add_option("-t",
"--template",
action="store",
dest="controlfile",
default=None,
help="Generate default controlfile")
parser.add_option("-l",
"--logfile",
action="store",
dest="logfile",
default=None,
help="Writes output to logfile")
parser.add_option("-d",
"--debug",
action="store_true",
dest="debug",
default=False,
help="Writes output to logfile")
parser.add_option("-c",
"--case",
action="store",
dest="case",
default=None,
help="Specifies case directory")
(options, args) = parser.parse_args()
rootLogger = logging.getLogger('')
logger = logging.getLogger('windRunner')
reportLevel = logging.INFO
if options.quiet:
reportLevel = logging.WARNING
if options.debug:
reportLevel = logging.DEBUG
rootLogger.setLevel(reportLevel)
if options.logfile is None:
console = logging.StreamHandler()
console.setLevel(reportLevel)
formatter = logging.Formatter(
'%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
rootLogger.addHandler(console)
if options.controlfile is not None:
generateCf(options.controlfile, defaultCf)
print "Wrote default controlfile"
sys.exit(0)
if options.logfile is not None:
logFileName = path.abspath(options.logfile)
if not path.exists(path.dirname(logFileName)):
print "Bad argument, directory for logfile does not exist"
sys.exit(1)
logfile = logging.FileHandler(logFileName, "w")
logfile.setLevel(reportLevel)
formatter = logging.Formatter(
'%(name)-12s: %(levelname)-8s %(message)s')
logfile.setFormatter(formatter)
rootLogger.addHandler(logfile)
if len(args) != 1:
parser.error("Incorrect number of arguments")
cf = ControlFile.ControlFile(fileName=path.abspath(args[0]))
if options.case is not None:
casePath = path.abspath(options.case)
else:
casePath = os.getcwd()
caseName = path.basename(casePath)
ch = CaseHandler.CaseHandler(casePath)
wspeeds = cf.findScalarList("wspeeds:", optional=False)
wdirs = cf.findScalarList("wdirs:", optional=False)
iterations = cf.findScalar("iterations:", optional=False)
inlet_z0 = cf.findScalarList("z0:", optional=False)
z0Dict = {}
for i, wdir in enumerate(wdirs):
z0Dict[wdir] = inlet_z0[i]
fieldsToArchive = cf.findStringList("fieldsToArchive:", optional=False)
archiveDirName = cf.findString("flowArchiveDirName:", optional=False)
restoreArchived = cf.findBoolean("restoreArchived:",
optional=True,
default=False)
nodes = int(cf.findScalar("nodes:", optional=False))
CPUs = cf.findScalar("CPUs:", optional=True)
if CPUs is None:
nprocesses = 16 * nodes
else:
nprocesses = int(CPUs)
# -----------------------------------
solver = cf.findString("solver:", default="windFoam")
initCmds = cf.findStringList("initialize:", default=["setLanduse"])
flowArchive = FoamArchive.FoamArchive(casePath, archiveDirName)
nwdir = len(wdirs)
convTable = ConvergenceTable.ConvergenceTable(casePath)
logger.info("Running windRunner.py")
logger.info("Setup overview:")
logger.info(25 * "-")
logger.info("Case: " + caseName)
logger.info(25 * "-")
logger.info("Wind directions are: " + str(wdirs))
logger.info("Wind speeds are: " + str(wspeeds))
nruns = nwdir * len(wspeeds)
logger.info("Total number of runs: " + str(nruns))
logger.info(25 * "-")
logger.info("Number of iterations are: " + str(iterations))
logger.info("Number of nodes are: " + str(nodes))
logger.info("Fields to be archived: " + str(fieldsToArchive))
logger.info(50 * "=")
controlDict = ParameterFile(ch.controlDict())
# uses include file from 0/include
ABLConditions = ParameterFile(
path.join(ch.name, '0', 'include', 'ABLConditions'))
compression = controlDict.readParameter("writeCompression")
if compression == "compressed" or compression == "on":
filesToArchive = [field + ".gz" for field in fieldsToArchive]
else:
filesToArchive = fieldsToArchive
# booting lammachine for parallell execution
if nprocesses > 1:
Lam = LAMMachine(nr=nprocesses)
Lam.writeScotch(ch)
controlDict.replaceParameter("stopAt", "nextWrite")
timeLeft = iterations * nruns * 20
timeSpent = 05
timeCase = iterations * 20
timeEstimated = time.localtime(time.time() + timeLeft)
casesRun = 0
casesLeft = nruns
ch.backUpInitialFields()
logger.info("Backup made of initial fields")
for wspeed in wspeeds:
for wdir in wdirs:
timeInit = time.time()
controlDict.replaceParameter("writeInterval", str(iterations))
logger.info("Running calculations for dir: " + str(wdir) +
" speed: " + str(wspeed))
logger.info("Time left: " + str(timeLeft / 60.0) +
"min, Time spent: " + str(timeSpent / 60.0) + "min")
logger.info("Estimated time for finish: " + str(timeEstimated[:4]))
logger.info("Cases finished: " + str(casesRun) + " cases left: " +
str(casesLeft))
logger.info(" ")
ch.clearResults()
dirName = "wspeed_" + str(wspeed) + "_wdir_" + str(wdir)
logger.info("restoreArchived = " + str(restoreArchived))
if flowArchive.inArchive(dirName=dirName) and not restoreArchived:
logger.info('Results already in archive, moving on...')
casesRun += 1
casesLeft -= 1
timeCase = time.time() - timeInit
timeSpent += timeCase
timeLeft = casesLeft * timeCase
timeEstimated = time.localtime(time.time() + timeLeft)
continue
logger.info("...Modifying bc:s")
ch.modWindDir(ch.initialDir(), wdir)
logger.info("bc:s modified!")
ABLConditions.replaceParameter("Uref", "%f" % wspeed)
ABLConditions.replaceParameter("flowDir", dir2vec(wdir))
ABLConditions.replaceParameter("z0", 'uniform %f' % z0Dict[wdir])
for initCmd in initCmds:
initUtil = UtilityRunner(argv=[initCmd, "-case", casePath],
silent=True,
logname=initCmd)
initUtil.start()
if initUtil.runOK():
logger.info("Successfully finished: %s" % initCmd)
else:
logger.error("Error when running: %s" % initCmd)
sys.exit(1)
if restoreArchived and \
flowArchive.inArchive(dirName=dirName):
logger.info("Restoring archived flow fields")
flowArchive.restore(dirName, ch.initialDir(), fieldsToArchive)
for filename in fieldsToArchive:
flowArchive.getFile(outputFile=path.join(
ch.initialDir(), filename),
fileName=filename,
archiveDirName=dirName)
logger.info("Restored archived flow fields!")
if nprocesses > 1:
if Lam.machineOK():
decomposeCmd = "decomposePar"
decomposeUtil = UtilityRunner(
argv=[decomposeCmd, "-case", casePath],
silent=True,
logname="decomposePar")
logger.info("...Decomposing case to run on" +
str(Lam.cpuNr()) + str(" of processors"))
decomposeUtil.start()
if decomposeUtil.runOK():
logger.info("Case decomposed!")
else:
logger.error("Error when running decomposePar")
sys.exit()
else:
logger.error("Error: Could not start lam-machine")
sys.exit()
else:
Lam = None
logger.info("Serial Run chosen!")
logger.info("...Running solver for wind field")
windFoamSolver = ConvergenceRunner(
StandardLogAnalyzer(),
argv=[solver, "-case", casePath],
silent=True,
lam=Lam,
logname=solver)
windFoamSolver.start()
if windFoamSolver.runOK():
logger.info("Iterations finished for solver")
else:
logger.error("Error while running solver")
sys.exit()
if nprocesses > 1:
logger.info("Reconstructing decomposed case...")
reconstructCmd = "reconstructPar"
reconstructUtil = UtilityRunner(
argv=[reconstructCmd, "-latestTime", "-case", casePath],
silent=True,
logname="reconstrucPar")
reconstructUtil.start()
if reconstructUtil.runOK():
logger.info("recunstruction ready!")
else:
logger.error("Error while running recontructPar")
sys.exit(1)
logger.info("Removing decomposed mesh")
ch.execute("rm -r " + os.path.join(casePath, "processor*"))
logger.info("Removed decomposed mesh!")
convTable.addResidual("wd_" + str(wdir) + "_ws_" + str(wspeed),
solver, "linear_Ux", casesRun + 1)
convTable.addResidual("wd_" + str(wdir) + "_ws_" + str(wspeed),
solver, "linear_Uy", casesRun + 1)
convTable.addResidual("wd_" + str(wdir) + "_ws_" + str(wspeed),
solver, "linear_k", casesRun + 1)
convTable.addResidual("wd_" + str(wdir) + "_ws_" + str(wspeed),
solver, "linear_epsilon", casesRun + 1)
convTable.addProbes("wd_" + str(wdir) + "_ws_" + str(wspeed), "U",
casesRun + 1)
convTable.addProbes("wd_" + str(wdir) + "_ws_" + str(wspeed), "k",
casesRun + 1)
convTable.addProbes("wd_" + str(wdir) + "_ws_" + str(wspeed),
"epsilon", casesRun + 1)
convTable.addProbes("wd_" + str(wdir) + "_ws_" + str(wspeed), "p",
casesRun + 1)
logger.info("Archiving results from directory: %s" %
ch.latestDir())
# save latest concentration result files
solFiles = [
file for file in os.listdir(ch.latestDir())
if file in filesToArchive
]
for filename in solFiles:
dirName = "wspeed_" + str(wspeed) + "_wdir_" + str(wdir)
flowArchive.addFile(path.join(ch.latestDir(), filename),
dirName=dirName)
logger.info("Finished wdir: " + str(wdir) + " wspeed: " +
str(wspeed) + "Last iter = " + ch.getLast())
logger.info(" ")
casesRun += 1
casesLeft -= 1
timeCase = time.time() - timeInit
timeSpent += timeCase
timeLeft = casesLeft * timeCase
timeEstimated = time.localtime(time.time() + timeLeft)
ch.clearResults()
logger.info("Cleared all result directories exept: %s" %
(" ".join(ch.getTimes())))
ch.restoreInitialFields()
logger.info("Restored initital fields from backup copy")
# restoring windData dictionary to original state
ABLConditions.purgeFile()
convTable.writeProbes()
convTable.writeResiduals()
logger.info("Residuals and probes from solver " +
"written to case/convergence directory")
# Restoring controlDict to original state
controlDict.purgeFile()
logger.info("Finished batch calculation!")
argv += ["-region", theRegion]
f = open(
path.join(case, "system", theRegion,
"decomposeParDict"), "w")
writeDictionaryHeader(f)
f.write(str(gen))
f.close()
self.setLogname(default="Decomposer", useApplication=False)
run = UtilityRunner(
argv=argv,
silent=self.opts.progress or self.opts.silent,
logname=self.opts.logname,
compressLog=self.opts.compress,
server=self.opts.server,
noLog=self.opts.noLog,
logTail=self.opts.logTail,
echoCommandLine=self.opts.echoCommandPrefix,
jobId=self.opts.jobId)
run.start()
if theRegion != None and not decomposeParWithRegion:
print_("Syncing into master case")
regions.resync(theRegion)
if regions != None and not decomposeParWithRegion:
if not self.opts.keeppseudo:
print_("Removing pseudo-regions")
regions.cleanAll()
else:
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("-t",
"--template",
action="store",
dest="template",
help="Generate default controlfile")
parser.add_argument(
'-v',
action=VerboseAction,
dest='loglevel',
default=logging.INFO,
help='increase verbosity in terminal',
)
parser.add_argument(
'-l',
metavar='logfile',
action=LogFileAction,
dest='logfile',
help='write verbose output to logfile',
)
parser.add_argument(
"-c",
"--case",
action="store",
dest="case",
default=os.getcwd(),
help="Specifies case directory (default is current workdir)",
)
parser.add_argument(action="store",
dest="controlfile",
help="Controlfile for speciesRunner")
args = parser.parse_args()
if args.template is not None:
generateCf(args.template, defaultCf)
log.info('Wrote default controlfile')
sys.exit(0)
cf = ControlFile.ControlFile(fileName=args.controlfile)
caseName = path.basename(args.case)
ch = CaseHandler.CaseHandler(args.case)
wspeeds = cf.findScalarList("wspeeds:", optional=False)
wdirs = cf.findScalarList("wdirs:", optional=False)
iterations = cf.findScalar("iterations:", optional=False)
fieldsToArchive = cf.findStringList("fieldsToArchive:", optional=False)
flowArchiveDirName = cf.findString("flowArchiveDirName:",
optional=True,
default='flowArchive')
concArchiveDirName = cf.findString("concArchiveDirName:",
optional=True,
default='concArchive')
restoreArchived = cf.findBoolean("restoreArchived:",
optional=True,
default=False)
nodes = int(cf.findScalar("nodes:", optional=False))
CPUs = cf.findScalar("CPUs:", optional=True)
if CPUs is None:
nprocesses = CORES_PER_NODE * nodes
else:
nprocesses = int(CPUs)
#-----------------------------------
solver = cf.findString("solver:", default="speciesFoam")
initCmds = cf.findStringList("initialize:", default=[], optional=True)
flowArchive = FoamArchive.FoamArchive(args.case, flowArchiveDirName)
concArchive = FoamArchive.FoamArchive(args.case, concArchiveDirName)
nwdir = len(wdirs)
convTable = ConvergenceTable.ConvergenceTable(args.case)
log.info("Running speciesFoam")
log.info("Setup overview:")
log.info(25 * "-")
log.info("Case: " + caseName)
log.info(25 * "-")
log.info("Wind directions are: " + str(wdirs))
log.info("Wind speeds are: " + str(wspeeds))
nruns = nwdir * len(wspeeds)
log.info("Total number of runs: " + str(nruns))
log.info(25 * "-")
log.info("Number of iterations are: " + str(iterations))
log.info("Number of nodes are: " + str(nodes))
log.info("Fields to be archived: " + str(fieldsToArchive))
log.info(50 * "=")
controlDict = ParameterFile(ch.controlDict())
statisticsDict = ExtendedParameterFile.ExtendedParameterFile(
path.join(ch.systemDir(), "statisticsDict"))
if controlDict.readParameter("writeCompression") == "compressed":
filesToArchive = [field + ".gz" for field in fieldsToArchive]
flowFiles = [field + ".gz" for field in FLOW_FILES]
else:
filesToArchive = fieldsToArchive
flowFiles = FLOW_FILES
# booting lammachine for parallell execution
if nprocesses > 1:
Lam = LAMMachine(nr=nprocesses)
Lam.writeScotch(ch)
controlDict.replaceParameter("stopAt", "nextWrite")
timeLeft = iterations * nruns * 20
timeSpent = 05
timeCase = iterations * 20
timeEstimated = time.localtime(time.time() + timeLeft)
casesRun = 0
casesLeft = nruns
log.info("Backing up initial fields")
ch.backUpInitialFields()
log.info("Backup made of initial fields")
for wspeed in wspeeds:
for wdir in wdirs:
timeInit = time.time()
dirName = "wspeed_" + str(wspeed) + "_wdir_" + str(wdir)
if concArchive.inArchive(dirName=dirName) and not restoreArchived:
log.info(
'Results already in concentration archive, moving on...')
casesRun += 1
casesLeft -= 1
timeCase = time.time() - timeInit
timeSpent += timeCase
timeLeft = casesLeft * timeCase
timeEstimated = time.localtime(time.time() + timeLeft)
continue
if not flowArchive.inArchive(dirName=dirName):
log.warning("Missing flow files in dir: %s, moving on..." %
dirName)
casesRun += 1
casesLeft -= 1
timeCase = time.time() - timeInit
timeSpent += timeCase
timeLeft = casesLeft * timeCase
timeEstimated = time.localtime(time.time() + timeLeft)
continue
controlDict.replaceParameter("writeInterval", str(iterations))
log.info("Running calculations for dir: " + str(wdir) +
" speed: " + str(wspeed))
log.info("Time left: " + str(timeLeft / 60.0) +
"min, Time spent: " + str(timeSpent / 60.0) + "min")
log.info("Estimated time for finish: " + str(timeEstimated[:4]))
log.info("Cases finished: " + str(casesRun) + " cases left: " +
str(casesLeft))
log.info(" ")
ch.clearResults()
log.info("...Modifying bc:s")
for f in flowFiles:
ch.execute("rm " + path.join(ch.initialDir(), f))
ch.modWindDir(ch.initialDir(), wdir)
log.info("bc:s modified!")
log.info("Restoring archived flow fields")
flowArchive.restore(dirName, ch.initialDir(), flowFiles)
# for filename in flowFiles:
# flowArchive.getFile(
# outputFile=path.join(ch.initialDir(), filename),
# fileName=filename, archiveDirName=dirName
# )
log.info("Restored archived flow fields!")
for initCmd in initCmds:
initUtil = UtilityRunner(argv=[initCmd, "-case", args.case],
silent=True,
logname=initCmd)
initUtil.start()
if initUtil.runOK():
log.info("Successfully finished: %s" % initCmd)
else:
log.error("Error when running: %s" % initCmd)
sys.exit(1)
if nprocesses > 1:
if Lam.machineOK():
decomposeCmd = "decomposePar"
decomposeUtil = UtilityRunner(
argv=[decomposeCmd, "-case", args.case],
silent=True,
logname="decomposePar")
log.info("Decomposing case for %i processors" %
Lam.cpuNr())
decomposeUtil.start()
if decomposeUtil.runOK():
log.info("Case decomposed!")
else:
log.error("Error when running decomposePar")
sys.exit()
else:
log.error("Error: Could not start lam-machine")
sys.exit()
else:
Lam = None
log.info("Serial Run chosen!")
log.info("...Running solver for species")
FoamSolver = ConvergenceRunner(StandardLogAnalyzer(),
argv=[solver, "-case", args.case],
silent=True,
lam=Lam,
logname=solver)
FoamSolver.start()
if FoamSolver.runOK():
log.info("Iterations finished for speciesFoam")
else:
log.error("Error while running speciesFoam")
sys.exit()
if nprocesses > 1:
log.info("Reconstructing decomposed case...")
reconstructCmd = "reconstructPar"
reconstructUtil = UtilityRunner(
argv=[reconstructCmd, "-case", args.case],
silent=True,
logname="reconstrucPar")
reconstructUtil.start()
if reconstructUtil.runOK():
log.info("recunstruction ready!")
else:
log.error("Error while running recontructPar")
sys.exit()
log.info("Removing decomposed mesh")
ch.execute("rm -r " + os.path.join(args.case, "processor*"))
log.info("Removed decomposed mesh!")
iterationsReady = (int(ch.getLast()) -
int(path.basename(ch.initialDir())))
if iterationsReady < iterations:
log.warning("Run was aborted before finalizing" +
" the wanted number of iterations")
log.warning("Guessing that nan:s were present in results. " +
"Removing results from current run and moving on")
log.info("Archiving results")
# save latest concentration result files
solFiles = [
f for f in os.listdir(ch.latestDir())
if f[:4] == "spec" and f[:12] != "spec_default"
and ".bak" not in f and "~" not in f and "#" not in f
]
for filename in solFiles:
dirName = "wspeed_" + str(wspeed) + "_wdir_" + str(wdir)
concArchive.addFile(path.join(ch.latestDir(), filename),
dirName=dirName)
convTable.addResidual("wd_" + str(wdir) + "_ws_" + str(wspeed),
"speciesFoam", "linear_" + filename,
casesRun + 1)
convTable.addProbes("wd_" + str(wdir) + "_ws_" + str(wspeed),
filename, casesRun + 1)
log.info("Residuals and probes from solver " +
"speciesFoam added to convergence table")
# Adding the list of names of archived concentration
# files to the statisticsDict dictionary
archivedConcFiles = concArchive.listFilesInDirs("spec_")
statisticsDict.replaceParameterList("concFileList",
archivedConcFiles)
log.info("Finished wdir: %f, wspeed: %f, Last iter: %s" %
(wdir, wspeed, ch.getLast()))
log.info(" ")
casesRun += 1
casesLeft -= 1
timeCase = time.time() - timeInit
timeSpent += timeCase
timeLeft = casesLeft * timeCase
timeEstimated = time.localtime(time.time() + timeLeft)
ch.clearResults()
ch.restoreInitialFields()
log.info("Restored initital fields")
# restoring windData dictionary to original state
convTable.writeProbes()
convTable.writeResiduals()
log.info("Residuals and probes from solver windFoam " +
"written to case/convergence directory")
# Restoring controlDict to original state
controlDict.purgeFile()
log.info("Finished batch calculation!")
# Set the boundary condition at the inlet
val = (maximum * i) / nr
print "Inlet velocity:", val
sol.replaceBoundary("inlet", "(%f 0 0)" % (val))
# Run the solver
run = ConvergenceRunner(BoundingLogAnalyzer(),
argv=[solver, "-case", case],
silent=True)
run.start()
print "Last Time = ", dire.getLast()
# Get the pressure difference (Using an external utility)
pUtil = UtilityRunner(argv=[pCmd, "-case", case],
silent=True,
logname="Pressure")
pUtil.add("deltaP", "Pressure at .* Difference .*\] (.+)")
pUtil.start()
deltaP = pUtil.get("deltaP")[0]
# Get the mass flow
mUtil = UtilityRunner(argv=[mCmd, "-case", case, "-latestTime"],
silent=True,
logname="MassFlow")
mUtil.add("mass", "Flux at (.+?) .*\] (.+)", idNr=1)
mUtil.start()
massFlow = mUtil.get("mass", ID="outlet")[0]
def main():
parser = OptionParser(usage=usage, version=version)
parser.add_option("-q",
"--quiet",
action="store_true",
dest="quiet",
default=False,
help="Only print warnings and errors")
parser.add_option("-t",
"--template",
action="store",
dest="controlfile",
default=None,
help="Generate default controlfile")
parser.add_option("-l",
"--logfile",
action="store",
dest="logfile",
default=None,
help="Writes output to logfile")
parser.add_option("-d",
"--debug",
action="store_true",
dest="debug",
default=False,
help="Writes output to logfile")
parser.add_option("-c",
"--case",
action="store",
dest="case",
default=None,
help="Specifies case directory")
(options, args) = parser.parse_args()
rootLogger = logging.getLogger('')
logger = logging.getLogger('canopyRunner')
reportLevel = logging.INFO
if options.quiet:
reportLevel = logging.WARNING
if options.debug:
reportLevel = logging.DEBUG
rootLogger.setLevel(reportLevel)
if options.logfile == None:
console = logging.StreamHandler()
console.setLevel(reportLevel)
formatter = logging.Formatter(
'%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
rootLogger.addHandler(console)
if options.controlfile != None:
generateCf(path.abspath(options.controlfile))
print "Wrote default controlfile"
sys.exit()
if options.logfile != None:
logFileName = path.abspath(options.logfile)
if not path.exists(path.dirname(logFileName)):
print "Bad argument, directory for logfile does not exist"
sys.exit()
logfile = logging.FileHandler(logFileName, "w")
logfile.setLevel(reportLevel)
formatter = logging.Formatter(
'%(name)-12s: %(levelname)-8s %(message)s')
logfile.setFormatter(formatter)
rootLogger.addHandler(logfile)
if len(args) != 1:
parser.error("Incorrect number of arguments")
cf = ControlFile.ControlFile(fileName=path.abspath(args[0]))
if options.case != None:
casePath = path.abspath(options.case)
else:
casePath = os.getcwd()
caseName = path.basename(casePath)
ch = CaseHandler.CaseHandler(casePath)
wspeeds = cf.findScalarList("wspeeds:", optional=False)
wdirs = cf.findScalarList("wdirs:", optional=False)
iterations = cf.findScalar("iterations:", optional=False)
inletProfile_z0 = cf.findScalar("z0:", optional=False)
fieldsToArchive = cf.findStringList("fieldsToArchive:", optional=False)
archiveDirName = cf.findString("flowArchiveDirName:", optional=False)
restoreArchived = cf.findBoolean("restoreArchived:",
optional=True,
default=False)
archiveVTK = cf.findBoolean("archiveVTK:", optional=False)
VTKArchiveDir = cf.findExistingPath("VTKArchiveDir:", optional=False)
nodes = int(cf.findScalar("nodes:", optional=False))
CPUs = cf.findScalar("CPUs:", optional=True)
if CPUs == None:
nprocesses = 8 * nodes
else:
nprocesses = int(CPUs)
#-----------------------------------
solver = cf.findString("solver:", default="windFoam")
softStart = cf.findString("softstart_application:", optional=True)
initCmds = cf.findStringList("initialize:", default=["setWindInlet"])
flowArchive = FoamArchive.FoamArchive(casePath, archiveDirName)
nwdir = len(wdirs)
convTable = ConvergenceTable.ConvergenceTable(casePath)
logger.info("Running windRunner.py")
logger.info("Setup overview:")
logger.info(25 * "-")
logger.info("Case: " + caseName)
logger.info(25 * "-")
logger.info("Wind directions are: " + str(wdirs))
logger.info("Wind speeds are: " + str(wspeeds))
nruns = nwdir * len(wspeeds)
logger.info("Total number of runs: " + str(nruns))
logger.info(25 * "-")
logger.info("Number of iterations are: " + str(iterations))
logger.info("Number of nodes are: " + str(nodes))
logger.info("Fields to be archived: " + str(fieldsToArchive))
logger.info("ArchiveToVTK is set to: " + str(archiveVTK))
logger.info(50 * "=")
controlDict = ParameterFile(ch.controlDict())
windDict = ParameterFile(path.join(ch.constantDir(), "windDict"))
RASDict = ParameterFile(path.join(ch.constantDir(), "RASProperties"))
compression = controlDict.readParameter("writeCompression")
if compression == "compressed" or compression == "on":
filesToArchive = [field + ".gz" for field in fieldsToArchive]
else:
filesToArchive = fieldsToArchive
if not path.exists(VTKArchiveDir) and archiveVTK:
logger.error("The VTKArchiveDir does not exist")
sys.exit()
#booting lammachine for parallell execution
if nprocesses > 1:
Lam = LAMMachine(nr=nprocesses)
Lam.writeScotch(ch)
controlDict.replaceParameter("stopAt", "nextWrite")
timeLeft = iterations * nruns * 20
timeSpent = 05
timeCase = iterations * 20
timeEstimated = time.localtime(time.time() + timeLeft)
casesRun = 0
casesLeft = nruns
ch.backUpInitialFields()
logger.info("Backup made of initial fields")
for wspeed in wspeeds:
for wdir in wdirs:
timeInit = time.time()
controlDict.replaceParameter("writeInterval", str(iterations))
logger.info("Running calculations for dir: " + str(wdir) +
" speed: " + str(wspeed))
logger.info("Time left: " + str(timeLeft / 60.0) +
"min, Time spent: " + str(timeSpent / 60.0) + "min")
logger.info("Estimated time for finish: " + str(timeEstimated[:4]))
logger.info("Cases finished: " + str(casesRun) + " cases left: " +
str(casesLeft))
logger.info(" ")
ch.clearResults()
dirName = "wspeed_" + str(wspeed) + "_wdir_" + str(wdir)
logger.info("restoreArchived = " + str(restoreArchived))
if restoreArchived and flowArchive.inArchive(dirName=dirName):
logger.info("Restoring archived flow fields")
flowArchive.restore(dirName, fieldsToArchive, ch.initialDir())
for filename in fieldsToArchive:
flowArchive.getFile(outputFile=path.join(
ch.initialDir(), filename),
fileName=filename,
archiveDirName=dirName)
logger.info("Restored archived flow fields!")
else:
logger.info("...Modifying bc:s")
ch.modWindDir(ch.initialDir(), wdir)
logger.info("bc:s modified!")
logger.info("...Setting inlet profiles")
windDict.replaceParameter("U10", str(wspeed))
windDict.replaceParameter("windDirection", str(wdir))
windDict.replaceParameter("z0", str(inletProfile_z0))
for initCmd in initCmds:
initUtil = UtilityRunner(argv=[initCmd, "-case", casePath],
silent=True,
logname=initCmd)
initUtil.start()
if initUtil.runOK():
logger.info("Successfully finished: %s" % initCmd)
else:
logger.error("Error when running: %s" % initCmd)
sys.exit()
if nprocesses > 1:
if Lam.machineOK():
decomposeCmd = "decomposePar"
decomposeUtil = UtilityRunner(
argv=[decomposeCmd, "-case", casePath],
silent=True,
logname="decomposePar")
logger.info("...Decomposing case to run on" +
str(Lam.cpuNr()) + str(" of processors"))
decomposeUtil.start()
if decomposeUtil.runOK():
logger.info("Case decomposed!")
else:
logger.error("Error when running decomposePar")
sys.exit()
else:
logger.error("Error: Could not start lam-machine")
sys.exit()
else:
Lam = None
logger.info("Serial Run chosen!")
if softStart != None:
RASDict.replaceParameter("RASModel", "kEpsilon")
controlDict.replaceParameter("stopAt", "nextWrite")
controlDict.replaceParameter("writeInterval", "50")
logger.info("...Softstarting using " + softStart)
windFoamSolver = ConvergenceRunner(
StandardLogAnalyzer(),
argv=[softStart, "-case", casePath],
silent=True,
lam=Lam,
logname=softStart)
windFoamSolver.start()
if windFoamSolver.runOK():
logger.info("Iterations finished for windFoam")
else:
logger.error("Error while running windFoam")
sys.exit()
RASDict.replaceParameter("RASModel", "kEpsilon_canopy")
controlDict.replaceParameter("writeInterval", str(iterations))
# The folowing line is to copy the landuse and LAD-files after the first iterations with simpleFoam
ch.execute(
"for file in " +
os.path.join(casePath, "processor*/0/[Ll]*") +
r'; do for folder in ${file%0*}*; do [ -e ${folder}/`basename ${file}` ] || cp $file ${folder}/`basename ${file}`; done; done'
)
logger.info("...Running solver for wind field")
windFoamSolver = ConvergenceRunner(
StandardLogAnalyzer(),
argv=[solver, "-case", casePath],
silent=True,
lam=Lam,
logname=solver)
windFoamSolver.start()
if windFoamSolver.runOK():
logger.info("Iterations finished for windFoam")
else:
logger.error("Error while running windFoam")
sys.exit()
if nprocesses > 1:
logger.info("Reconstructing decomposed case...")
reconstructCmd = "reconstructPar"
reconstructUtil = UtilityRunner(
argv=[reconstructCmd, "-latestTime", "-case", casePath],
silent=True,
logname="reconstrucPar")
reconstructUtil.start()
if reconstructUtil.runOK():
logger.info("recunstruction ready!")
else:
logger.error("Error while running recontructPar")
sys.exit()
logger.info("Removing decomposed mesh")
ch.execute("rm -r " + os.path.join(casePath, "processor*"))
logger.info("Removed decomposed mesh!")
convTable.addResidual("wd_" + str(wdir) + "_ws_" + str(wspeed),
solver, "linear_Ux", casesRun + 1)
convTable.addResidual("wd_" + str(wdir) + "_ws_" + str(wspeed),
solver, "linear_Uy", casesRun + 1)
convTable.addResidual("wd_" + str(wdir) + "_ws_" + str(wspeed),
solver, "linear_k", casesRun + 1)
convTable.addResidual("wd_" + str(wdir) + "_ws_" + str(wspeed),
solver, "linear_epsilon", casesRun + 1)
convTable.addProbes("wd_" + str(wdir) + "_ws_" + str(wspeed), "U",
casesRun + 1)
convTable.addProbes("wd_" + str(wdir) + "_ws_" + str(wspeed), "k",
casesRun + 1)
convTable.addProbes("wd_" + str(wdir) + "_ws_" + str(wspeed),
"epsilon", casesRun + 1)
convTable.addProbes("wd_" + str(wdir) + "_ws_" + str(wspeed), "p",
casesRun + 1)
logger.info("Archiving results from directory: %s" %
ch.latestDir())
#save latest concentration result files
solFiles = [
file for file in os.listdir(ch.latestDir())
if file in filesToArchive
]
for filename in solFiles:
dirName = "wspeed_" + str(wspeed) + "_wdir_" + str(wdir)
flowArchive.addFile(path.join(ch.latestDir(), filename),
dirName=dirName)
if archiveVTK:
#Creating a temporary last time directory to be used by foamToVTK
VTKTime = str(eval(path.basename(ch.latestDir())) + 1)
newTimeDir = path.join(casePath, VTKTime)
os.mkdir(newTimeDir)
for filename in solFiles:
oldFile = path.join(casePath, str(eval(ch.getLast()) - 1),
filename)
ch.execute("cp " + oldFile + " " + newTimeDir + "/")
foamToVTKUtil = UtilityRunner(
argv=["foamToVTK", "-case", casePath, "-time " + VTKTime],
silent=True,
logname="foamToVTK")
foamToVTKUtil.start()
if foamToVTKUtil.runOK():
ch.execute("mv " + path.join(casePath, "VTK") + " " +
path.join(
VTKArchiveDir, "VTK" + "_wspeed_" +
str(wspeed) + "_wdir_" + str(wdir)))
ch.execute("rm -r " + path.join(casePath, VTKTime))
logger.info("Exported to VTK archive!")
else:
logger.error("Error when exporting to VTK")
sys.exit()
logger.info("Finished wdir: " + str(wdir) + " wspeed: " +
str(wspeed) + "Last iter = " + ch.getLast())
logger.info(" ")
casesRun += 1
casesLeft -= 1
timeCase = time.time() - timeInit
timeSpent += timeCase
timeLeft = casesLeft * timeCase
timeEstimated = time.localtime(time.time() + timeLeft)
ch.clearResults()
logger.info("Cleared all result directories exept: %s" %
(" ".join(ch.getTimes())))
ch.restoreInitialFields()
logger.info("Restored initital fields from backup copy")
#restoring windData dictionary to original state
windDict.purgeFile()
convTable.writeProbes()
convTable.writeResiduals()
logger.info(
"Residuals and probes from solver windFoam written to case/convergence directory"
)
#Restoring controlDict to original state
controlDict.purgeFile()
logger.info("Finished batch calculation!")
