Example #1
0
def SolverRun():
    p = projectutils.getActiveProject()

    if not p.runs:
        quickui.error("You should create a Run before doing this operation.")
        return
    SolverExecute(p=p,run=p.activerun)
Example #2
0
File: run.py Project: ro21han/hifun
def editRun(project=None, runname=None):
    p = project or projectutils.getActiveProject()
    runname = runname or p.activerun
    p.setActiveRun(runname)
    treepath = os.path.join(p[runname]['path'], "run.tree")
    runTree = common.parseTree(treepath, root=runname)
    projectconfigpath = p['projectdir']
    response = quickui.showConfigurationTree(title=runname, tree=runTree, savespace=p[runname]['path'], parent=tool.getToolWindow())
    p.save()
Example #3
0
File: run.py Project: ro21han/hifun
def chooseAndEditRun(project=None):
    project = projectutils.getActiveProject()
    runnames = project.getRunNames()
    r = {}
    for name in runnames:
        r[name] = name
    c = quickui.createWidget(quickid="runname", description="Choose Run", type="Enum", value=project.activerun, options=r)
    runname = quickui.showDialog(c)
    print runname
    if runname:
        editRun(project=project, runname=runname)
Example #4
0
def set_Serial_Preprocess_Data(x={},p=None):
    p = p or projectutils.getActiveProject()

    x['path']=path=p['projectdir']

    mshfile=p['mshfile']

    if mshfile.endswith(".msh.gz"):
       ext = ".msh.gz"
    elif mshfile.endswith(".msh.GZ"):
       ext = "msh.GZ"
    else:
       ext = ".msh"
    filename = os.path.basename(mshfile).replace(ext,".geo")

    if not 'cexepath' in x.keys():
       x['cexepath']=os.getcwd()

    x['geofile'] = os.path.join(path, filename)

    filename = os.path.basename(mshfile).replace(ext,".OUT")

    x['outfilename']=os.path.join(path, filename)

    x['scale'] = p['scale']

    x['nodecellfile']=os.path.join(path,"NODECELL.OUT")
    x['cellfacefile']=os.path.join(path,"CELLFACE.OUT")

    x['min_dist_file']=os.path.join(path,"min_distance.out")

    x['fsupportfile']=os.path.join(path,"FSUPPORT.OUT")

    x['graphfile']=os.path.join(path,"unstructured.graph")

    x['zip_opt']=p['zip_opt']

    x['cellzone_file']=os.path.join(x['path'],"cellzone.dat")

    if int(x['zip_opt']):
       #x['geofile']=x['geofile']+'.gz'
       x['cmd']='gunzip -c'
    else:
       x['cmd']='cat'

    x['convert3dout']=x['geofile']
    x['geofile_2d']=os.path.join(path,"2Dgeom.geo")
Example #5
0
    def __init__(self, project=None, runname=None):
        self.project = projectutils.getActiveProject()

        self.runname=runname

        if not self.runname:
            self.runname = p.activerun
        
        path=os.path.join(self.project[self.runname]['path'],"run.tree")
        self.runtree=common.parseTree(path,root=self.runname)
        self.path= self.project[self.runname]['path']
          
        self.bcs=self.project['bcs']
        self.cellzone=self.project['cellzone']
 
        self.configs = self._readConfigTree()
        solverdata=self._getSolverData()
        self.rans_dir=os.path.join(self.project[self.runname]['path'],'Flowsolver_input')
        
        if not os.path.isdir(self.rans_dir):
	   os.mkdir(self.rans_dir)
           if not os.path.isdir(self.rans_dir):
	      quickui.error(message='Unbale to create Flowsolver_input dorectory.')
              raise OSError('Unbale to create Flowsolver_input dorectory.')

        templatePath=self._getTemplate('userchoice.inp_template')
        self._writeSolverData('/userchoice.inp',solverdata,templatePath,)
        templatePath=self._getTemplate('freestream.inp_template')
        self._writeSolverData('/freestream.inp',solverdata,templatePath,)
        templatePath=self._getTemplate('run_option.inp_template')
        self._writeSolverData('run_option.inp',solverdata,templatePath,)
        templatePath=self._getTemplate('boundary_information.inp_template')
        self._writeSolverData('boundary_information.inp',solverdata,templatePath,)
        templatePath=self._getTemplate('lift_drag_contrib.inp_template')
        self._writeSolverData('lift_drag_contrib.inp',solverdata,templatePath,)
        templatePath=self._getTemplate('halt.inp_template')
        self._writeSolverData('halt.inp',solverdata,templatePath,)

	self.createSubdLink()
Example #6
0
File: run.py Project: ro21han/hifun
def createRun(project=None):
    p = project or projectutils.getActiveProject()

    if p.runs:
        i = 1
        name = "Default_Run" + str(i)
        while name in p.runs:
            i = i + 1
            name = "Default_Run" + str(i)
    else:
        name = "Default_Run"

    runname = quickui.createWidget(quickid="run", description="Name of Run", type="String", value=name)
    subdomains = quickui.createWidget(type="Integer", quickid="subdomains", value=2, description="Number of Subdomains")
    group=quickui.createWidget(type="Group", quickid="rundetails" ,components=[runname,subdomains])
    v = quickui.showDialog(group, parent=tool.getToolWindow())

    if not v:
        return

    preprocess.executeParallelPreprocessor(p,v['subdomains'])
    p.createRun(runname=v['run'], subdomains = v['subdomains'])
    p.save()
    return v['run']
Example #7
0
    def __init__(self,p=None,run=None):
	
	self.project=p or projectutils.getActiveProject()
	self.runname=run or self.project[self.runname]['name']
	self.no_of_subd=self.project[self.runname]['subdomains']
	self.runpath=os.path.join(self.project[self.runname]['path'])
	self.rep=project.getRepository()
	self.machfile=project.getMachineFile()
	self.flags=project.getSolverFlags()

	self.subd_dir=os.path.join(self.project['projectdir'],'Subds_')+str(self.no_of_subd)
	self.subd_dir_link=os.path.join(self.runpath,'Subdomains')

        if not os.path.isfile(os.path.join(self.runpath,'Flowsolver_input/userchoice.inp')) or \
	   not os.path.isfile(os.path.join(self.runpath,'Flowsolver_input/freestream.inp')) or \
	   not os.path.isfile(os.path.join(self.runpath,'Flowsolver_input/run_option.inp')) or \
	   not os.path.isfile(os.path.join(self.runpath,'Flowsolver_input/boundary_information.inp')) or \
	   not os.path.isfile(os.path.join(self.runpath,'Flowsolver_input/lift_drag_contrib.inp')):
	   quickui.error(message='Required Flow solver input files are not available for current run.\nPlease check.')
	   raise IOError('Required Flow solver input files are not available for current run. Please check.')

        if not self.machfile or not os.path.isfile(self.machfile):
	   quickui.error(message='Required Machine file is not found. Unable to execute.')
	   raise IOError('Required Machine file is not found. Unable to execute.')

        if os.path.exists(self.subd_dir):
	   if not os.path.islink(self.subd_dir_link) and not os.path.realpath(self.subd_dir_link)==self.subd_dir:
	      quickui.error(message='Invalid Subdomain directory.\nPlease check.')
	      raise IOError('Invalid Subdomain directory. Please check.')
	else:
	   quickui.error(message='Unable to locate subdomain directory.\nPlease check.')
	   raise IOError('Unable to locate subdomain directory. Please check.')

	extra_lib_path=os.getenv('EXTRA_LIB')
	flist=os.listdir(extra_lib_path)
	openmpi_dir=None
	pt=re.compile(('openmpi.'))
	for item in flist:
	    if re.match(pt,item):
	       openmpi_dir=os.path.join(extra_lib_path,item)
	       break
        if not openmpi_dir or not os.path.exists(openmpi_dir):
	   quickui.error(message='Unable to locate openmpi.\nPlease check.')
	   raise IOError('Unable to locate openmpi. Please check.')

	mpiexe=os.path.join(openmpi_dir,'bin/mpirun')

	if not os.path.isfile(mpiexe):
           quickui.error(message='Unable to locate mpirun command.\nPlease check.')
           raise IOError('Unable to locate mpirun command. Please check.')

	rans_exe=os.path.join(const.home,'bin/rans_3d_tempfac_mod2_WF')

	solvercmd=[mpiexe,'-machinefile',self.machfile,'-np',str(self.no_of_subd),rans_exe]
	if self.flags:
	   solvercmd.insert(1,self.flags)
	cpath=os.getcwd()
	os.chdir(self.runpath)
	p1=subprocess.Popen(solvercmd)

	p1.wait()
	os.chdir(cpath)
Example #8
0
def writeSolverData():
    p = projectutils.getActiveProject()
    if not p.runs:
        quickui.error("You should create a Run before doing this operation.")
        return
    SolverInpWriter(project=p, runname=p.activerun)