def AppendInitFile(self):
#Read init_domain.c from the Src/Templates folder.
inidomainfl_name = self.pluto_dir + '/Src/Templates/init_domain.c'
pf1 = pfIO.PlutoFiles(inidomainfl_name)
#Convert the contents of file init_domain.c into a list
inidomain = pf1.File2List()
#Check if the init.c file exists in the work directory
inifl_exits = os.path.exists(self.ini_fname)
#If it does read the file and convert it contents into a list
# Then break the list into part above the Init Function and part below the Init Function.
if inifl_exits:
pf = pfIO.PlutoFiles(self.ini_fname)
nlist = pf.File2List()
scrh1 = pf.LocateString(
'void Init (double *v, double x1, double x2, double x3)\n')
scrh3 = pf.LocateString('void InitDomain (Data *d, Grid *grid)\n')
if len(scrh1) == 0:
for item in nlist:
line = item.split()
if any(x in line for x in ["void", "Init", "Init(double"]):
lindx1 = nlist.index(item)
break
else:
lindx1 = scrh1[0][0]
# If the InitDomain function is not present in the init.c file then
# read line by line from the Init Function till you get number
# of open curly brackets equal to close curly brackets.
if len(scrh3) == 0:
l1 = nlist[0:lindx1]
l2 = nlist[lindx1:]
opBracket = 0
clBracket = 0
addIndx = 0
for item in l2:
line = item.split()
addIndx += 1
if ((len(line) > 0) and (line[0] != '*')):
for w in line:
if "{" in list(w): opBracket += 1
if "}" in list(w): clBracket += 1
if (opBracket > 0):
if (opBracket == clBracket):
addline = addIndx
break
# Finally create a new list by adding the content of init_domain.c file
NewInit = l1 + l2[:addline] + inidomain + l2[addline:]
# Create the new init.c file.
pf.List2File(NewInit)
def ProcessUserDefPara(self):
"""
Sets the Userdefined parameters
"""
self.udef_params = ['USER_PAR_%.2d' % i for i in range(self.nparam)]
if (os.path.exists(self.work_dir + '/definitions.h')):
pf = pfIO.PlutoFiles(self.work_dir + '/definitions.h')
scrh = pf.LocateString('parameters')
k0 = scrh[0][0] + 2
par_lines = pf.ReadLines(k0, k0 + self.nparam)
for n in range(self.nparam):
try:
x = par_lines[n].split()
x[0] == '#define'
except IndexError:
pass
else:
if (x[0] == "#define"):
self.udef_params[n] = x[1]
else:
break
if self.auto_update == 0:
menu.SetTitle("User-defined Parameters")
par_entries = ['%d' % i for i in range(self.nparam)]
menu.Insert(par_entries, self.udef_params)
def ChkCompatiblity(self):
oldKeys_ = ['INTERPOLATION','MHD_FORMULATION','RESISTIVE_MHD']
replaceKeys_ = ['RECONSTRUCTION','DIVB_CONTROL','RESISTIVITY']
if (os.path.exists(self.work_dir+'/definitions.h')):
pf = pfIO.PlutoFiles(self.work_dir+'/definitions.h')
for i in range(len(oldKeys_)):
pf.ReplaceWord(oldKeys_[i], replaceKeys_[i])
def ReadOrBrowse(self, Ents=None, Opts=None, Defs=None, MenuTitle=None):
"""Reads or Browses the entries, options and defaults to create header file.
This method either reads the already exsisting definitions.h file or browses
throught the three lists which are provided as inputs.
**Inputs**:
1. Ents = List of entries. [None]
2. Opts = List of options corresponding to each member in Ents [None]
3. Defs = List of default value from Opts corresponding to each member in Ents [None]
4. MenuTitle = Title for the Menu to be Browsed [None]
"""
if (os.path.exists(self.work_dir + '/definitions.h')):
pf = pfIO.PlutoFiles(self.work_dir + '/definitions.h')
pf.UpdateListFromFile(Ents, Defs)
for i in range(len(Ents)):
if Defs[i] not in Opts[i]:
Defs[i] = Opts[i][0]
else:
pass
# Provides Browsing options using the menu file in case of no automatic update flag.
if self.auto_update == 0:
selection = ''
menu.SetTitle(MenuTitle)
selection = menu.Browse(Ents, default=Defs, options=Opts)
def ChomboMakeVars(self):
"""Adds CHOMBO specific vars in the Makefile.
This method of the MakeProblem class does necessary
modification to the makefile so as to accomodate
compilation of chombo (AMR) specific variables.
"""
pf = pfIO.PlutoFiles(self.work_dir + '/definitions.h')
scrh = pf.LocateString('DIMENSIONS')
dims = scrh[0][1].split()[2]
chombo_config_string = 'DIM=' + dims
if '--with-chombo:' in sys.argv:
i = sys.argv.index('--with-chombo:') + 1
try:
sys.argv[1:]
except IndexError:
print "Additional Configration Details Required for '--with-chombo:' flag"
sys.exit()
else:
for y in sys.argv[i:]:
chombo_config_string += ' ' + y
self.row += 1
menu.Print(" - Chombo config string: " + chombo_config_string,
row=self.row)
self.row += 1
menu.Print(" - creating make.vars...", row=self.row, sleep=0)
os.chdir(self.pluto_dir + "/Lib/Chombo-3.2/lib")
os.system("make " + chombo_config_string + " vars > make.vars\n")
os.system("cp make.vars " + self.work_dir + "\n")
os.chdir(self.work_dir)
def ProcessUserDefConst(self):
"""
Sets the Userdefined Constants.
"""
self.udef_const = ['USER_CONST_%.2d'%i for i in range(self.nconst)]
self.udef_const_vals = self.nconst*['YES']
if (os.path.exists(self.work_dir+'/definitions.h')):
pf = pfIO.PlutoFiles(self.work_dir+'/definitions.h')
scrh = pf.LocateString('constants')
k0 = scrh[0][0] + 2
const_lines = pf.ReadLines(k0, k0 + self.nconst)
for n in range(self.nconst):
try:
x = const_lines[n].split()
x[0] == '#define'
except IndexError:
pass
else:
if (x[0] == "#define"):
self.udef_const[n] = x[1]
self.udef_const_vals[n] = x[2]
else:
break;
if self.auto_update == 0:
menu.SetTitle ("User-defined constants")
const_entries = ['%d'%i for i in range(self.nconst)]
menu.Insert(const_entries,self.udef_const)
menu.SetTitle ("User-defined constant values")
menu.Insert(self.udef_const, self.udef_const_vals)
def SetArch(self):
"""Sets the Architecture for compilation of code.
This attribute of the MakeProblem class looks for the
'ARCH' keyword in makefile and if not defined will define it
based on user's choice of the Makefile configuration
from the Config/ folder. If already defined then will use
that architecture for compilation of Makefile.
"""
mkfl_exits = os.path.exists(self.mkfl_name)
if mkfl_exits:
pf = pfIO.PlutoFiles(self.mkfl_name)
scrh = pf.LocateString('ARCH')
if self.auto_update == 0 or not mkfl_exits or len(scrh[0]) == 0:
def_list = []
entries = os.listdir(self.pluto_dir + '/Config')
for def_file in entries:
if (def_file.endswith('.defs')): def_list.append(def_file)
def_list.sort()
menu.SetTitle("Change makefile")
self.arch = menu.Browse(def_list)
self.arch_string = 'ARCH = ' + self.arch + '\n'
else:
self.arch_string = scrh[0][1]
self.arch = self.arch_string.split()[2]
def UpdateMkflTemplate(self):
"""
Updates Makefile with additional flags, files and modular makefile paths.
"""
shutil.copy(self.pluto_dir + self.makefile_template, self.mkfl_name)
pf = pfIO.PlutoFiles(self.mkfl_name)
pf.ReplaceWord('PLUTO_DIR',
'PLUTO_DIR = ' + self.pluto_dir + '\n',
DelOld=True)
pf.ReplaceWord('ARCH', self.arch_string, DelOld=True)
scrh = pf.LocateString('Additional_header_files_here')
ipos = scrh[0][0] + 3
for x in self.header_files:
pf.InsertLine('HEADERS += ' + x + '\n', ipos)
ipos = ipos + 1
scrh = pf.LocateString('Additional_object_files_here')
ipos = scrh[0][0] + 3
for x in self.additional_files:
pf.InsertLine('OBJ += ' + x + '\n', ipos)
ipos = ipos + 1
for x in self.pluto_path:
pf.InsertLine('include $(SRC)/' + x + 'makefile' + '\n', ipos)
ipos = ipos + 1
for x in self.additional_flags:
pf.InsertLine('CFLAGS += ' + x + '\n', ipos)
ipos = ipos + 1
def NonUserFriendlyConst(self):
"""
Sets the non-user friendly constants.
"""
tmplist1 = [
'INITIAL_SMOOTHING', 'WARNING_MESSAGES', 'PRINT_TO_FILE',
'INTERNAL_BOUNDARY', 'SHOCK_FLATTENING'
]
tmplist2 = len(tmplist1) * ['NO']
if self.flag_dict['WITH-CHOMBO']:
tmplist1 += ['CHOMBO_EN_SWITCH', 'CHOMBO_REF_VAR', 'CHOMBO_LOGR']
tmplist2 += ['NO', 'ENG', 'NO']
if not self.flag_dict['WITH-FD']:
tmplist1 = tmplist1 + [
'ARTIFICIAL_VISCOSITY', 'CHAR_LIMITING', 'LIMITER'
]
tmplist2 = tmplist2 + ['NO', 'NO', 'DEFAULT']
if 'MHD_FORMULATION' in self.mod_entries:
divb_mode = self.mod_default[self.mod_entries.index(
'MHD_FORMULATION')]
if divb_mode == 'CONSTRAINED_TRANSPORT':
tmplist1 = tmplist1 + [
'CT_EMF_AVERAGE', 'CT_EN_CORRECTION',
'ASSIGN_VECTOR_POTENTIAL'
]
tmplist2 = tmplist2 + ['UCT_HLL', 'NO', 'YES']
else:
tmplist1 = tmplist1 + ['ASSIGN_VECTOR_POTENTIAL']
tmplist2 = tmplist2 + ['NO']
if not self.flag_dict['WITH-CHOMBO']:
tmplist1 = tmplist1 + ['UPDATE_VECTOR_POTENTIAL']
tmplist2 = tmplist2 + ['NO']
if 'HANCOCK' in self.default:
if (self.phymodule == 'RMHD'):
tmplist1 = tmplist1 + ['PRIMITIVE_HANCOCK']
tmplist2 = tmplist2 + ['NO']
else:
tmplist1 = tmplist1 + ['PRIMITIVE_HANCOCK']
tmplist2 = tmplist2 + ['YES']
if 'SUPER_TIME_STEPPING' in self.mod_default:
tmplist1 = tmplist1 + ['STS_nu']
tmplist2 = tmplist2 + ['0.01']
longword = max(len(w) for w in tmplist1)
if (os.path.exists(self.work_dir + '/definitions.h')):
pf = pfIO.PlutoFiles(self.work_dir + '/definitions.h')
pf.UpdateListFromFile(tmplist1, tmplist2)
self.non_usfr = [
'#define ' + tmplist1[i].ljust(longword + 3) + tmplist2[i] + '\n'
for i in range(len(tmplist1))
]
def UpdatePlutoIni(self):
"""
Updates pluto.ini file with values of UserDefined Parameters
"""
pf = pfIO.PlutoFiles(self.work_dir + '/pluto.ini')
scrh = pf.LocateString('[Parameters]')
try:
scrh[0]
except IndexError:
print("Parameters keyword not found in pluto.ini")
sys.exit()
else:
pass
ipos = scrh[0][0] + 2
tmplist1 = pf.ReadLines(ipos, ipos + 512)
paradict = {}
cmms = []
for x in tmplist1:
if (len(x.split()) == 0): continue # skip blank lines
paradict.update({x.split()[0]: x.split()[1]})
try:
cmmval = x.split()[2]
except IndexError:
cmms.append('')
continue
else:
if cmmval == '#' or cmmval.startswith('#'):
cmms.append(' '.join(x.split()[2:]))
else:
cmms.append('')
for x in self.udef_params:
if x in paradict.keys():
pf.InsertLine(
x.ljust(28) + paradict[x] + ' ' +
cmms[self.udef_params.index(x)] + '\n', ipos)
else:
try:
cmms[self.udef_params.index(x)]
except IndexError:
pf.InsertLine(x.ljust(28) + '0.0' + '\n', ipos)
else:
pf.InsertLine(
x.ljust(28) + '0.0' + ' ' +
cmms[self.udef_params.index(x)] + '\n', ipos)
ipos = ipos + 1
pf.DeleteLines(ipos, ipos + 100)
def ProcessUserDefConst(self):
"""
Sets the Userdefined Constants.
"""
if (os.path.exists(self.work_dir + '/definitions.h')):
pf = pfIO.PlutoFiles(self.work_dir + '/definitions.h')
old_beg_scrh = pf.LocateString('symbolic')
try:
old_beg_scrh[0][0]
except IndexError:
pass
else:
del_indx = pf.LocateString('USER_DEF_CONSTANTS')
pf.DeleteLines(del_indx[0][0], del_indx[0][0])
old_beg_scrh = pf.LocateString('symbolic')
pf.ReplaceLine(
'/* [Beg] user-defined constants (do not change this line) */',
old_beg_scrh[0][0])
old_end_scrh = pf.LocateString('supplementary')
pf.InsertLine(
'/* [End] user-defined constants (do not change this line) */',
old_end_scrh[0][0] - 1)
scrh_beg = pf.LocateString('[Beg]')
k_beg = scrh_beg[0][0] + 1
scrh_end = pf.LocateString('[End]')
k_end = scrh_end[0][0] - 1
const_lines = pf.ReadLines(k_beg, k_end)
#print const_lines
for n in range(len(const_lines)):
x = const_lines[n].split()
try:
x[0] == '#define'
except IndexError:
pass
else:
if (x[0] == '#define'):
self.udef_const.append(x[1])
self.udef_const_vals.append(x[2])
else:
continue
def ProcessUserDefConst(self):
"""
Sets the Userdefined Constants.
"""
if (os.path.exists(self.work_dir + '/definitions.h')):
pf = pfIO.PlutoFiles(self.work_dir + '/definitions.h')
scrh_beg = pf.LocateString('User_Constants_Beg')
k_beg = scrh_beg[0][0] + 1
scrh_end = pf.LocateString('User_Constants_End')
k_end = scrh_end[0][0] - 1
const_lines = pf.ReadLines(k_beg, k_end)
print const_lines
for n in range(len(const_lines)):
x = const_lines[n].split()
try:
x[0] == '#define'
except IndexError:
pass
else:
if (x[0] == '#define'):
self.udef_const.append(x[1])
self.udef_const_vals.append(x[2])
else:
continue
def __init__(self, work_dir, pluto_dir, auto_update):
"""Defines the problem for the PLUTO code.
This class essentially creates the definitions.h file
based on the inputs given by the user from the PlutoSetup menu.
In case the header file is already present, this class will
read those default values to re-create the file.
**Inputs**:
1. work_dir = Path to PLUTO code working directory
2. pluto_dir = Path to PLUTO source directory
3. auto-update = Boolean that indicates auto-update of definitions.h file.
**Output**:
It generates a definitions.h file.
"""
#Some class attributes that will be used in various class methods.
self.work_dir = work_dir
self.ini_fname = self.work_dir + '/init.c'
self.pluto_dir = pluto_dir
self.krome_dir = pluto_dir + '/Src/Cooling/KROME/krome/'
self.auto_update = auto_update
self.def_fname = self.work_dir + '/definitions.h'
self.additional_files = []
self.header_files = []
self.additional_flags = []
self.pluto_path = []
self.def_file_list = []
self.ChkCompatiblity() #To Replace Old Keywords with New Ones
# defining the PLUTO entries and its default values in lists.
self.entries = [
'PHYSICS', 'DIMENSIONS', 'COMPONENTS', 'GEOMETRY', 'BODY_FORCE',
'FORCED_TURB', 'COOLING', 'RECONSTRUCTION', 'TIME_STEPPING',
'DIMENSIONAL_SPLITTING', 'NTRACER', 'USER_DEF_PARAMETERS'
]
self.default = [
'HD', '1', '1', 'CARTESIAN', 'NO', 'NO', 'NO', 'LINEAR', 'RK2',
'NO', '0', '0'
]
# Creating a dictionary of flags that are invoked by giving arguments.
flag_keys = [
'WITH-CHOMBO', 'FULL', 'WITH-FD', 'WITH-SB', 'WITH-FARGO',
'WITH-PARTICLES', 'WITH-CR_TRANSPORT'
]
#self.flag_dict = {key: False for key in flag_keys} DOESNT WORK WITH PYTHON 2.6
self.flag_dict = {
'WITH-CHOMBO': False,
'FULL': False,
'WITH-FD': False,
'WITH-SB': False,
'WITH-FARGO': False,
'WITH-PARTICLES': False,
'WITH-CR_TRANSPORT': False
}
for arg in sys.argv:
if arg[2:].upper() in flag_keys:
self.flag_dict[arg[2:].upper()] = True
elif arg[2:] == 'with-chombo:':
self.flag_dict['WITH-CHOMBO'] = True
else:
pass
# Generates Full Option List.
self.GenerateOptionsList()
# !!!!!!!!!!! CR_TRANSPORT !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# if (self.flag_dict['WITH-CR_TRANSPORT'] == True):
# self.options[self.entries.index('PHYSICS')] = ['CR_TRANSPORT']
# else:
# i = self.entries.index('PHYSICS')
# self.options[i].remove('CR_TRANSPORT')
# print self.options[self.entries.index('PHYSICS')]
# print self.entries
# print self.options
#
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#Updates Options, default based on FLAGS.
if True in self.flag_dict.values():
self.AfterFlagLists()
#Read the exsisting definition.h file or Browse the menu for Setting up problem.
self.ReadOrBrowse(Ents=self.entries,
Defs=self.default,
Opts=self.options,
MenuTitle="Setup problem")
#Process the PHYSICS Modules.
if self.default[self.entries.index('PHYSICS')] == 'HD':
self.ProcessHDModule()
self.ReadOrBrowse(Ents=self.entries_HD,
Defs=self.default_HD,
Opts=self.options_HD,
MenuTitle="HD Menu")
self.eos = self.default_HD[self.entries_HD.index('EOS')]
if self.default[self.entries.index('PHYSICS')] == 'RHD':
self.ProcessRHDModule()
self.ReadOrBrowse(Ents=self.entries_RHD,
Defs=self.default_RHD,
Opts=self.options_RHD,
MenuTitle="RHD Menu")
self.eos = self.default_RHD[self.entries_RHD.index('EOS')]
if self.default[self.entries.index('PHYSICS')] == 'MHD':
self.ProcessMHDModule()
self.ReadOrBrowse(Ents=self.entries_MHD,
Defs=self.default_MHD,
Opts=self.options_MHD,
MenuTitle="MHD Menu")
self.eos = self.default_MHD[self.entries_MHD.index('EOS')]
if self.default[self.entries.index('PHYSICS')] == 'RMHD':
self.ProcessRMHDModule()
self.ReadOrBrowse(Ents=self.entries_RMHD,
Defs=self.default_RMHD,
Opts=self.options_RMHD,
MenuTitle="RMHD Menu")
self.eos = self.default_RMHD[self.entries_RMHD.index('EOS')]
if self.default[self.entries.index('PHYSICS')] == 'CR_TRANSPORT':
self.ProcessCR_TransportModule()
self.ReadOrBrowse(Ents=self.entries_CR_TRANSPORT,
Defs=self.default_CR_TRANSPORT,
Opts=self.options_CR_TRANSPORT,
MenuTitle="CR_Transport Menu")
self.eos = self.default_CR_TRANSPORT[
self.entries_CR_TRANSPORT.index('EOS')]
# Process the KROME cooling module when required.
if self.default[self.entries.index('COOLING')] == 'KROME':
self.ProcessKROMEModule()
self.ReadOrBrowse(Ents=self.entries_KROME,
Defs=self.default_KROME,
Opts=self.options_KROME,
MenuTitle="KROME Menu")
self.WriteKromeOpts()
#UserDef Para and Constants
self.udef_params = []
self.udef_const = []
self.udef_const_vals = []
self.nparam = int(
self.default[self.entries.index('USER_DEF_PARAMETERS')])
#self.nconst = int(self.default[self.entries.index('USER_DEF_CONSTANTS')])
if self.nparam > 0:
self.ProcessUserDefPara()
self.ProcessUserDefConst()
# Write a List def_file_list which will be written as the header file.
self.WriteDefFileList()
pf = pfIO.PlutoFiles(self.work_dir + '/definitions.h')
pf.List2File(self.def_file_list)
self.AppendInitFile()
def NonUserFriendlyConst(self):
"""
Sets the non-user friendly constants. : OBSOLETE
This function only stores the Non-User Friendly constants
whose values are different than their DEFAULT values and
incorporates them in User Defined Constants.
"""
self.non_usfr = []
tmplist1 = [
'INITIAL_SMOOTHING', 'WARNING_MESSAGES', 'INTERNAL_BOUNDARY',
'SHOCK_FLATTENING'
]
tmplist2 = ['NO', 'YES', 'NO', 'NO']
tmplist2_def = ['NO', 'YES', 'NO', 'NO']
# if self.flag_dict['WITH-CHOMBO']:
# tmplist1 += ['CHOMBO_REF_VAR','CHOMBO_LOGR']
# tmplist2 += ['ENG', 'NO']
if not self.flag_dict['WITH-FD']:
tmplist1 = tmplist1 + ['CHAR_LIMITING', 'LIMITER']
tmplist2 = tmplist2 + ['NO', 'DEFAULT']
tmplist2_def = tmplist2_def + ['NO', 'DEFAULT']
if 'DIVB_CONTROL' in self.mod_entries:
divb_mode = self.mod_default[self.mod_entries.index(
'DIVB_CONTROL')]
if divb_mode == 'CONSTRAINED_TRANSPORT':
tmplist1 = tmplist1 + [
'CT_EMF_AVERAGE', 'CT_EN_CORRECTION',
'ASSIGN_VECTOR_POTENTIAL'
]
tmplist2 = tmplist2 + ['UCT_HLL', 'NO', 'NO']
tmplist2_def = tmplist2_def + ['UCT_HLL', 'NO', 'NO']
else:
tmplist1 = tmplist1 + ['ASSIGN_VECTOR_POTENTIAL']
tmplist2 = tmplist2 + ['NO']
tmplist2_def = tmplist2_def + ['NO']
if not self.flag_dict['WITH-CHOMBO']:
tmplist1 = tmplist1 + ['UPDATE_VECTOR_POTENTIAL']
tmplist2 = tmplist2 + ['NO']
tmplist2_def = tmplist2_def + ['NO']
# if 'HANCOCK' in self.default:
# if (self.phymodule == 'RMHD'):
# tmplist1 = tmplist1 + ['PRIMITIVE_HANCOCK']
# tmplist2 = tmplist2 + ['NO']
# else:
# tmplist1 = tmplist1 + ['PRIMITIVE_HANCOCK']
# tmplist2 = tmplist2 + ['YES']
longword = max(len(w) for w in tmplist1)
if (os.path.exists(self.work_dir + '/definitions.h')):
pf = pfIO.PlutoFiles(self.work_dir + '/definitions.h')
scrh = pf.LocateString('supplementary')
try:
scrh[0]
except IndexError:
pass
else:
pf.UpdateListFromFile(tmplist1, tmplist2)
for i in range(len(tmplist1)):
if tmplist2[i] != tmplist2_def[i]:
self.non_usfr = self.non_usfr + [
'#define ' + tmplist1[i].ljust(28) + ' ' + tmplist2[i] +
'\n'
]
def check(pluto_dir, get_arch):
work_dir = os.getcwd()
print("\n>> Inspecting system configuration << \n")
log_file = work_dir + '/sysconf.out'
python_dir = pluto_dir + '/Tools/Python'
param_file = pluto_dir + '/Src/pluto.h'
os.chdir(python_dir)
log = []
# ---------------------
# get user name
# ---------------------
try:
user = os.getlogin()
except OSError:
user = '******'
# ---------------------
# get system spec.
# ---------------------
PLATFORM = os.uname()
# ---------------------
# find current
# version of PLUTO
# ---------------------
pf = pfIO.PlutoFiles(param_file)
scrh = pf.LocateString("PLUTO_VERSION")
ipos = scrh[0][0]
vers = scrh[0][1].split()[-1]
# ------------------------------
# print a short system summary
# ------------------------------
print("User.......................", user)
print("System name................", PLATFORM[0])
print("Node name..................", PLATFORM[1])
print("Release....................", PLATFORM[2])
print("Arch.......................", PLATFORM[4])
print("Byteorder..................", sys.byteorder)
print("Version....................", PLATFORM[3])
print("Working_dir................", work_dir)
print("PLUTO main dir.............", pluto_dir)
print("PLUTO version..............", vers)
# --------------------------------------
# Check for gcc or another c compiler
# --------------------------------------
compiler_list = ['gcc', 'cc', 'gcc2']
COMPILER_NAME = ''
for x in compiler_list:
if (CHECK_FOR(x) == 'YES'):
print("C Compiler................. ", x)
COMPILER_NAME = x
break
if (COMPILER_NAME == ''):
print("! Can not find a C compiler !")
# -----------------
# check for mpi
# -----------------
mpi_compiler_list = ['mpicc', 'mpiCC', 'mpcc_r', 'hcc', 'mpcc']
MPI_COMPILER_NAME = ''
for x in mpi_compiler_list:
if (CHECK_FOR(x) == 'YES'):
print("MPI Compiler .............. ", x)
MPI_COMPILER_NAME = x
break
if (MPI_COMPILER_NAME == ''):
print("MPI Compiler............... NOT FOUND")
if (get_arch):
print("\n")
print("Proposed makefile names: \n")
print("> " + PLATFORM[0] + "." + PLATFORM[4] + "." + COMPILER_NAME +
".defs")
print("> " + PLATFORM[0] + "." + PLATFORM[4] + "." +
MPI_COMPILER_NAME + ".defs")
# ---------------------------------------------------
# Build log list, that will be compared to the
# sysconf.out file.
# ---------------------------------------------------
log.append("USER = "******"WORKING_DIR = " + work_dir + "\n")
log.append("SYSTEM_NAME = " + PLATFORM[0] + "\n")
log.append("NODE_NAME = " + PLATFORM[1] + "\n")
log.append("RELEASE = " + PLATFORM[2] + "\n")
log.append("ARCH = " + PLATFORM[4] + "\n")
log.append("BYTE_ORDER = " + sys.byteorder + "\n")
log.append("VERSION = " + PLATFORM[3] + "\n")
log.append("PLUTO_DIR = " + pluto_dir + '\n')
log.append("PLUTO_VERSION = " + vers + '\n')
log.append("C_COMPILER = " + COMPILER_NAME + '\n')
log.append("MPI_C_COMPILER = " + MPI_COMPILER_NAME + '\n')
# ----------------------------
# check for online updates
# ----------------------------
print("\n> Checking for updates (canceled)...\n")
# try:
# urllib.urlretrieve("http://plutocode.ph.unito.it/updates.txt","updates.txt")
# scrh = file.word_find ("updates.txt","release")
# ipos = scrh[0]
# scrh = file.read_lines ("updates.txt", ipos, ipos + 1)
# rels = string.split(scrh[0])
# if (rels[1] != vers):
# print " ******************************************************* "
# print " A new version of PLUTO ("+rels[1]+") is available at"
# print " http://plutocode.oato.inaf.it"
# print " *******************************************************\n"
# scrh = raw_input("> Press enter to continue.")
# os.chdir(work_dir)
# except:
# print "! Connection not available\n"
# ------------------------------------------------
# Compare the list 'log' with the file log_file;
#
# - if they match, no update is necessary,
# ==> return to main menu
#
# - if they do not match or if log_file does not
# exists, create a new one
#
# ------------------------------------------------
if (os.path.exists(log_file)):
pf = pfIO.PlutoFiles(log_file)
scrh = pf.ReadLines(0, 128)
if (scrh[0:] == log[0:]):
os.chdir(work_dir)
return
else:
print(
"\n> System configuration file is not up to date. Updating...")
else:
print("\n> System configuration file not found, creating one...")
pf = pfIO.PlutoFiles(log_file)
pf.List2File(log)
# ------------
# Make Tools
# ------------
# print (" > Making binary tools in "+bintools_dir+"...")
# os.chdir(bintools_dir)
# os.system('make -s clean')
# os.system('make -s dbl2flt')
# os.system('make -s bin2ascii')
# if (HAVE_LIBPNG == 'YES'):
# os.system('make -s bin2png')
# ---------------------------
# Add important info here
# ---------------------------
# scrh = raw_input(" > Press enter to continue.")
os.chdir(work_dir)
return
