def __init__(self,path_mcmax='runTest',replace_db_entry=0,db=None,\ new_entries=[],single_session=0): """ Initializing an instance of ModelingSession. @keyword db: the MCMax database (default: None) @type db: Database() @keyword replace_db_entry: replace an entry in the MCMax database with a newly calculated model with a new model id (for instance if some general data not included in the inputfiles is changed) (default: 0) @type replace_db_entry: bool @keyword path_mcmax: modeling folder in MCMax home (default: 'runTest') @type path_mcmax: string @keyword new_entries: The new model_ids when replace_db_entry is 1 of other models in the grid. These are not replaced! (default: []) @type new_entries: list[str] @keyword single_session: If this is the only CC session. Speeds up db check. (default: 0) @type single_session: bool """ super(MCMax, self).__init__(code='MCMax',path=path_mcmax,\ replace_db_entry=replace_db_entry,\ new_entries=new_entries,\ single_session=single_session) #-- Convenience path cc.path.mout = os.path.join(cc.path.mcmax, self.path) DataIO.testFolderExistence(os.path.join(cc.path.mout,\ 'data_for_gastronoom')) self.db = db self.mcmax_done = False #-- If an mcmax model is in progress, the model manager will hold until # the other cc session is finished. self.in_progress = False #- Read standard input file with all parameters that should be included #- as well as some dust specific information inputfilename = os.path.join(cc.path.aux, 'inputMCMax.dat') self.standard_inputfile = DataIO.readDict(inputfilename,\ convert_floats=1,\ convert_ints=1,\ comment_chars=['#','*'])
def copyOutput(self,entry,old_id,new_id): ''' Copy modelling output based on model_id. @param entry: the modeling object for which output is copied @type entry: Molecule() or Transition() @param old_id: The old model_id @type old_id: string @param new_id: the new_model_id @type new_id: string ''' folder_old = os.path.join(cc.path.gout,'models',old_id) folder_new = os.path.join(cc.path.gout,'models',new_id) lsprocess = subprocess.Popen('ls %s'%folder_old,shell=True,\ stdout=subprocess.PIPE) lsfile = lsprocess.communicate()[0].split('\n') lsfile = [os.path.split(line)[1] for line in lsfile if ((line[0:2] == 'ml' or line[0:4] == 'cool') \ and not entry.isMolecule()) \ or line[0:7] == 'coolfgr' \ or line[0:4] == 'para' \ or line[0:5] == 'input'] if not entry.isMolecule(): lsfile = [line for line in lsfile if not (line[0:2] == 'ml' \ and line.split('_')[-1].replace('.dat','') \ != entry.molecule.molecule)] lsfile = [line for line in lsfile if not (line[0:4] == 'cool' \ and (line.split('_')[-1].replace('.dat','') \ != entry.molecule.molecule \ or line.split('_')[-1].replace('.dat','')=='sampling'\ or line[0:7] == 'coolfgr'))] new_lsfile = [line.replace(old_id,new_id) for line in lsfile] DataIO.testFolderExistence(folder_new) lsprocess = subprocess.Popen('ls %s'%folder_new,shell=True,\ stdout=subprocess.PIPE) already_done = lsprocess.communicate()[0].split('\n') for ls,nls in zip(lsfile,new_lsfile): if not nls in already_done: subprocess.call(['ln -s %s %s'%(os.path.join(folder_old,ls),\ os.path.join(folder_new,nls))],\ shell=True)
def copyOutput(self, entry, old_id, new_id): ''' Copy modelling output based on model_id. @param entry: the modeling object for which output is copied @type entry: Molecule() or Transition() @param old_id: The old model_id @type old_id: string @param new_id: the new_model_id @type new_id: string ''' folder_old = os.path.join(cc.path.gout, 'models', old_id) folder_new = os.path.join(cc.path.gout, 'models', new_id) lsprocess = subprocess.Popen('ls %s'%folder_old,shell=True,\ stdout=subprocess.PIPE) lsfile = lsprocess.communicate()[0].split('\n') lsfile = [os.path.split(line)[1] for line in lsfile if ((line[0:2] == 'ml' or line[0:4] == 'cool') \ and not entry.isMolecule()) \ or line[0:7] == 'coolfgr' \ or line[0:4] == 'para' \ or line[0:5] == 'input'] if not entry.isMolecule(): lsfile = [line for line in lsfile if not (line[0:2] == 'ml' \ and line.split('_')[-1].replace('.dat','') \ != entry.molecule.molecule)] lsfile = [line for line in lsfile if not (line[0:4] == 'cool' \ and (line.split('_')[-1].replace('.dat','') \ != entry.molecule.molecule \ or line.split('_')[-1].replace('.dat','')=='sampling'\ or line[0:7] == 'coolfgr'))] new_lsfile = [line.replace(old_id, new_id) for line in lsfile] DataIO.testFolderExistence(folder_new) lsprocess = subprocess.Popen('ls %s'%folder_new,shell=True,\ stdout=subprocess.PIPE) already_done = lsprocess.communicate()[0].split('\n') for ls, nls in zip(lsfile, new_lsfile): if not nls in already_done: subprocess.call(['ln -s %s %s'%(os.path.join(folder_old,ls),\ os.path.join(folder_new,nls))],\ shell=True)
def __init__(self,code,path,replace_db_entry=0,new_entries=[],\ single_session=0): """ Initializing an instance of ModelingSession. @param code: code for which the modelingsession is created @type code: string @param path: modeling output folder in the code's home folder @type path: string @keyword replace_db_entry: replace an entry in the database with a newly calculated model with a new model id (eg if some general data not included in the inputfiles is changed) (default: 0) @type replace_db_entry: bool @keyword new_entries: The new model_ids when replace_db_entry is 1 of other models in the grid. These are not replaced! (default: []) @type new_entries: list[str] @keyword single_session: If this is the only CC session. Speeds up db check. (default: 0) @type single_session: bool """ self.path = path self.code = code self.model_id = '' self.replace_db_entry = replace_db_entry self.new_entries = new_entries self.single_session = single_session if code == 'Chemistry': self.mutable = [] else: mutablefile = os.path.join(cc.path.aux,\ 'Mutable_Parameters_%s.dat'%code) self.mutable = [line[0] for line in DataIO.readFile(mutablefile,delimiter=' ') if ' '.join(line)] self.mutable = [line for line in self.mutable if line[0] != '#'] fout = os.path.join(getattr(cc.path,self.code.lower()),self.path) DataIO.testFolderExistence(os.path.join(fout,'models'))
def __init__(self,code,path,replace_db_entry=0,new_entries=[],\ single_session=0): """ Initializing an instance of ModelingSession. @param code: code for which the modelingsession is created @type code: string @param path: modeling output folder in the code's home folder @type path: string @keyword replace_db_entry: replace an entry in the database with a newly calculated model with a new model id (eg if some general data not included in the inputfiles is changed) (default: 0) @type replace_db_entry: bool @keyword new_entries: The new model_ids when replace_db_entry is 1 of other models in the grid. These are not replaced! (default: []) @type new_entries: list[str] @keyword single_session: If this is the only CC session. Speeds up db check. (default: 0) @type single_session: bool """ self.path = path self.code = code self.model_id = '' self.replace_db_entry = replace_db_entry self.new_entries = new_entries self.single_session = single_session if code == 'Chemistry': self.mutable = [] else: mutablefile = os.path.join(cc.path.aux,\ 'Mutable_Parameters_%s.dat'%code) self.mutable = [ line[0] for line in DataIO.readFile(mutablefile, delimiter=' ') if ' '.join(line) ] self.mutable = [line for line in self.mutable if line[0] != '#'] fout = os.path.join(getattr(cc.path, self.code.lower()), self.path) DataIO.testFolderExistence(os.path.join(fout, 'models'))
def setOutputFolders(self): ''' Set the output folders. If the folders do not already exist, they are created. The locations are saved in cc.path for later use, but this is generally only done inside a ComboCode session. Each module sets these themselves ''' cc.path.gout = os.path.join(cc.path.gastronoom,self.path_gastronoom) cc.path.mout = os.path.join(cc.path.mcmax,self.path_mcmax) DataIO.testFolderExistence(cc.path.gout) DataIO.testFolderExistence(cc.path.mout)
def __init__(self,path_mcmax='runTest',replace_db_entry=0,db=None,\ new_entries=[]): """ Initializing an instance of ModelingSession. @keyword db: the MCMax database (default: None) @type db: Database() @keyword replace_db_entry: replace an entry in the MCMax database with a newly calculated model with a new model id (for instance if some general data not included in the inputfiles is changed) (default: 0) @type replace_db_entry: bool @keyword path_mcmax: modeling folder in MCMax home (default: 'runTest') @type path_mcmax: string @keyword new_entries: The new model_ids when replace_db_entry is 1 of other models in the grid. These are not replaced! (default: []) @type new_entries: list[str] """ super(MCMax, self).__init__(code='MCMax',path=path_mcmax,\ replace_db_entry=replace_db_entry,\ new_entries=new_entries) #-- Convenience path cc.path.mout = os.path.join(cc.path.mcmax,self.path) DataIO.testFolderExistence(os.path.join(cc.path.mout,\ 'data_for_gastronoom')) self.db = db self.mcmax_done = False #- Read standard input file with all parameters that should be included #- as well as some dust specific information inputfilename = os.path.join(cc.path.aux,'inputMCMax.dat') self.standard_inputfile = DataIO.readDict(inputfilename,\ convert_floats=1,\ convert_ints=1,\ comment_chars=['#','*'])
def setFnPlt(self,fn_plt,fn_suffix='',fn_subfolder=''): ''' Create a plot filename. The base filename (fn_plt) defines which of 3 cases is requested: 1) path is given, and the object has fn_add_star set to 1. 2) path is given, and the object has fn_add_star set to 0. 3) path is not given, in which case the star name is never added (it is included in the default folder name) In all cases, a base filename must be given, and a suffix can be defined in addition. Returns empty string if fn_plt is not defined or empty. @param fn_plt: A plot filename that can be given to each plotting sub method, or through the cfg file (managed by the sub method). If not given, each sub method defines a default. This includes the path if required. @type fn_plt: string @keyword fn_suffix: An optional suffix to be appended to the filename (default: '') @type fn_suffix: str @keyword fn_subfolder: An additional subfolder in the default self.pplot can be added. Not used when path is included in fn_plt. (default: '') @type fn_subfolder: str @return: The full path + filename without extension is returned. @rtype: str ''' if not fn_plt: return '' #-- Split path and filename, remove extension. path, pfn = os.path.split(fn_plt) pfn = os.path.splitext(fn_plt)[0] #-- Add extra filename segments if path and self.fn_add_star: pfn = '_'.join([pfn,self.star_name]) if fn_suffix: pfn = '_'.join([pfn,fn_suffix]) #-- Copy inputfilename over to the plot id folder if it is made. if not path: DataIO.testFolderExistence(self.pplot) if not self.inputfilename is None: ipfn = os.path.split(self.inputfilename)[1] newf = os.path.join(self.pplot,ipfn) if not os.path.isfile(newf): subprocess.call([' '.join(['cp',self.inputfilename,newf])],\ shell=True) #-- Define default path, check if the path exists if not path and fn_subfolder: path = os.path.join(self.pplot,fn_subfolder) DataIO.testFolderExistence(path) elif not path: path = self.pplot return os.path.join(path,pfn)
def __convolveSphinx(self,star): ''' Check if sphinx output has already been convolved (pacs db) and do so if not. @param star: The parameter set @type star: Star() ''' #- check for which filenames the convolution has already been done finished_conv_filenames = self.checkStarDb(star) finished_conv_filenames = [this_f for this_f in finished_conv_filenames if this_f in [os.path.split(f)[1] for f in self.data_filenames]] #- if after db check pacs id is undefined, then there is no pacs model, #- and the convolution will be done anyway if self.redo_convolution and star['LAST_PACS_MODEL']: for filename in finished_conv_filenames: ori = os.path.join(cc.path.gout,'stars',self.star_name,\ 'PACS_results',star['LAST_PACS_MODEL'],\ '_'.join(['sphinx',filename])) backup = os.path.join(cc.path.gout,'stars',self.star_name,\ 'PACS_results',star['LAST_PACS_MODEL'],\ '_'.join(['backup','sphinx',filename])) subprocess.call(['mv %s %s'%(ori,backup)],shell=True) self.db[star['LAST_PACS_MODEL']]['filenames'] = [] finished_conv_filenames = [] filenames_to_do = [this_f for this_f in [os.path.split(f)[1] for f in self.data_filenames] if this_f not in finished_conv_filenames] #-Get sphinx model output and merge, for all star models in star_grid if filenames_to_do: #- if list is not empty, some filenames still need a convolution print '* Reading Sphinx model and merging.' merged = star['LAST_GASTRONOOM_MODEL'] \ and self.mergeSphinx(star) \ or [[],[]] sphinx_wave = merged[0] sphinx_flux = merged[1] if not sphinx_wave: print '* No Sphinx data found.' return #- convolve the model fluxes with a gaussian at central wavelength #- from data_wave_list for every star, and appropriate sigma print '* Convolving Sphinx model, after correction for v_lsr.' if not self.data_delta_list: self.setDataResolution() for filename in filenames_to_do: i_file = [os.path.split(f)[1] for f in self.data_filenames].index(filename) if not star['LAST_PACS_MODEL']: star['LAST_PACS_MODEL'] = \ 'pacs_%.4i-%.2i-%.2ih%.2i-%.2i-%.2i'\ %(gmtime()[0],gmtime()[1],gmtime()[2],\ gmtime()[3],gmtime()[4],gmtime()[5]) self.db[star['LAST_PACS_MODEL']] = \ dict([('filenames',[]),\ ('trans_list',star.getTransList(dtype='PACS')),\ ('cooling_id',star['LAST_GASTRONOOM_MODEL'])]) DataIO.testFolderExistence(\ os.path.join(cc.path.gout,'stars',self.star_name,\ 'PACS_results',star['LAST_PACS_MODEL'])) #-- Correct for the v_lsr of the central source sphinx_wave_corr = array(sphinx_wave)*(1./(1-self.vlsr/self.c)) sph_conv = Data.doConvolution(\ x_in=sphinx_wave_corr,\ y_in=sphinx_flux,\ x_out=self.data_wave_list[i_file],\ widths=self.data_delta_list[i_file],\ oversampling=self.oversampling) sph_fn = os.path.join(cc.path.gout,'stars',self.star_name,\ 'PACS_results',star['LAST_PACS_MODEL'],\ '_'.join(['sphinx',filename])) DataIO.writeCols(filename=sph_fn,\ cols=[self.data_wave_list[i_file],sph_conv]) self.db[star['LAST_PACS_MODEL']]['filenames'].append(filename) self.db.addChangedKey(star['LAST_PACS_MODEL'])
def __init__(self,star_name,oversampling,path=None,redo_convolution=0,\ intrinsic=1,path_linefit='',absflux_err=0.2): ''' Initializing an instance of Pacs(). @param star_name: Name of the star from Star.dat @type star_name: string @param oversampling: The PACS instrumental oversampling, for correct convolution of the Sphinx output] @type oversampling: int @keyword path: Output folder in the code's home folder. Used to locate the PACS database. If None, it is not used (eg for line measurement matching/identification) (default: None) @type path: string @keyword intrinsic: Use the intrinsic Sphinx line profiles for convolving with the spectral resolution? Otherwise the beam convolved line profiles are used. (default: 1) @type intrinsic: bool @keyword redo_convolution: if you want to do the convolution of the sphinx models regardless of what's already in the database. The pacs id will not change, nor the entry in the db, and the old convolved model will be copied to a backup (default: 0) @type redo_convolution: bool @keyword path_linefit: The folder name for linefit results from Hipe (created by Pierre, assuming his syntax). The folder is located in $path_pacs$/$star_name$/. If no folder is given, no linefits are processed. (default: '') @type path_linefit: string @keyword absflux_err: The absolute flux calibration uncertainty of the instrument. (default: 0.2) @type absflux_err: float ''' super(Pacs,self).__init__(star_name=star_name,code='GASTRoNOoM',\ path_linefit=path_linefit,path=path,\ absflux_err=absflux_err, oversampling=oversampling,\ instrument_name='PACS',intrinsic=intrinsic) self.data_wave_list = [] self.data_flux_list = [] self.data_ordernames = [] self.data_orders = [] self.data_delta_list = [] self.redo_convolution = redo_convolution #-- Convenience path cc.path.gout = os.path.join(cc.path.gastronoom,self.path) #-- Check the path for the PACS database if a model folder is known. if self.path <> None: self.db_path = os.path.join(cc.path.gout,'stars',self.star_name,\ 'GASTRoNOoM_pacs_models.db') self.db = Database.Database(self.db_path) DataIO.testFolderExistence(os.path.join(cc.path.gout,'stars',\ self.star_name,'PACS_results')) else: self.db = None self.sphinx_prep_done = 0 self.readLineFit()
def doCooling(self, star): """ Run Cooling. First, database is checked for retrieval of old model. @param star: The parameter set for this session @type star: Star() """ #-- Collect H2O and CO molecule definitions for inclusion in the # cooling inputfile. Also includes abundance_filename info for H2O if # requested if star.getMolecule('1H1H16O') <> None: h2o_dict = star.getMolecule('1H1H16O').makeDict() else: h2o_dict = Molecule('1H1H16O', 45, 45, 648, 50).makeDict() if star.getMolecule('12C16O') <> None: co_dict = star.getMolecule('12C16O').makeDict() else: co_dict = Molecule('12C16O', 61, 61, 240, 50).makeDict() #-- no abundance profiles should be possible for CO. if co_dict.has_key('MOLECULE_TABLE'): raise IOError('CO cannot be attributed a custom abundance ' + \ 'profile at this time.') #-- F_H2O is irrelevant if an abundance file is passed for oH2O if h2o_dict.has_key('MOLECULE_TABLE'): del self.command_list['F_H2O'] #-- Collect all H2O molecular information important for cooling molec_dict = dict([(k, h2o_dict[k]) for k in self.cooling_molec_keys if h2o_dict.has_key(k)]) #-- Check database: only include H2O extra keywords if # abundance_filename is present. CO can't have this anyway. model_bool = self.checkCoolingDatabase(molec_dict=molec_dict) #- Run cooling if above is False if not model_bool: DataIO.testFolderExistence(os.path.join(cc.path.gout,'models',\ self.model_id)) commandfile = ['%s=%s'%(k,v) for k,v in sorted(self.command_list.items()) if k != 'R_POINTS_MASS_LOSS'] + \ ['####'] + \ ['%s=%s'%(k,co_dict['MOLECULE'])] + \ ['%s=%s'%(k,h2o_dict[k]) for k in self.cooling_molec_keys + ['MOLECULE'] if h2o_dict.has_key(k)] + ['####'] if self.command_list.has_key('R_POINTS_MASS_LOSS'): commandfile.extend(['%s=%s'%('R_POINTS_MASS_LOSS',v) for v in self.command_list\ ['R_POINTS_MASS_LOSS']] + \ ['####']) filename = os.path.join(cc.path.gout,'models',\ 'gastronoom_' + self.model_id + '.inp') DataIO.writeFile(filename, commandfile) if not self.skip_cooling: self.execGastronoom(subcode='cooling', filename=filename) self.cool_done = True if os.path.isfile(os.path.join(cc.path.gout,'models',\ self.model_id,'coolfgr_all%s.dat'\ %self.model_id)): #-- Add the other input keywords for cooling to the H2O info. # This is saved to the db molec_dict.update(self.command_list) self.cool_db[self.model_id] = molec_dict self.cool_db.sync() else: print 'Cooling model calculation failed. No entry is added '+ \ 'to the database.' self.model_id = ''
def setFnPlt(self, fn_plt, fn_suffix='', fn_subfolder=''): ''' Create a plot filename. The base filename (fn_plt) defines which of 3 cases is requested: 1) path is given, and the object has fn_add_star set to 1. 2) path is given, and the object has fn_add_star set to 0. 3) path is not given, in which case the star name is never added (it is included in the default folder name) In all cases, a base filename must be given, and a suffix can be defined in addition. Returns empty string if fn_plt is not defined or empty. @param fn_plt: A plot filename that can be given to each plotting sub method, or through the cfg file (managed by the sub method). If not given, each sub method defines a default. This includes the path if required. @type fn_plt: string @keyword fn_suffix: An optional suffix to be appended to the filename (default: '') @type fn_suffix: str @keyword fn_subfolder: An additional subfolder in the default self.pplot can be added. Not used when path is included in fn_plt. (default: '') @type fn_subfolder: str @return: The full path + filename without extension is returned. @rtype: str ''' if not fn_plt: return '' #-- Split path and filename, remove extension. path, pfn = os.path.split(fn_plt) pfn = os.path.splitext(fn_plt)[0] #-- Add extra filename segments if path and self.fn_add_star: pfn = '_'.join([pfn, self.star_name]) if fn_suffix: pfn = '_'.join([pfn, fn_suffix]) #-- Copy inputfilename over to the plot id folder if it is made. if not path: DataIO.testFolderExistence(self.pplot) if not self.inputfilename is None: ipfn = os.path.split(self.inputfilename)[1] newf = os.path.join(self.pplot, ipfn) if not os.path.isfile(newf): subprocess.call([' '.join(['cp',self.inputfilename,newf])],\ shell=True) #-- Define default path, check if the path exists if not path and fn_subfolder: path = os.path.join(self.pplot, fn_subfolder) DataIO.testFolderExistence(path) elif not path: path = self.pplot return os.path.join(path, pfn)
def __init__(self,path_gastronoom='runTest',vic=None,sphinx=0,\ replace_db_entry=0,cool_db=None,ml_db=None,sph_db=None,\ skip_cooling=0,recover_sphinxfiles=0,\ new_entries=[]): """ Initializing an instance of a GASTRoNOoM modeling session. A single cooling model and a given set of molecules and transitions are calculated here or are retrieved from the databases. @keyword path_gastronoom: modeling folder in GASTRoNOoM home (default: 'runTest') @type path_gastronoom: string @keyword vic: the vic manager for running sphinx models on VIC3 (default: None) @type vic: Vic() @keyword sphinx: Running Sphinx? (default: 0) @type sphinx: bool @keyword replace_db_entry: replace an entry in the databases with a newly calculated model with a new model id (e.g. if some general data not included in the inputfiles is changed) (default: 0) @type replace_db_entry: bool @keyword new_entries: The new model_ids when replace_db_entry is 1 of other models in the grid. These are not replaced! (default: []) @type new_entries: list[str] @keyword skip_cooling: Skip running cooling in case a model is not found in the database, for instance if it is already known that the model will fail (default: 0) @type skip_cooling: bool @keyword recover_sphinxfiles: Try to recover sphinx files from the disk in case they were correctly calculated, but not saved to the database for one reason or another. (default: 0) @type recover_sphinxfiles: bool @keyword cool_db: the cooling database (default: None) @type cool_db: Database() @keyword ml_db: the mline database (default: None) @type ml_db: Database() @keyword sph_db: the sphinx database (default: None) @type sph_db: Database() """ super(Gastronoom,self).__init__(code='GASTRoNOoM',\ path=path_gastronoom,\ replace_db_entry=replace_db_entry,\ new_entries=new_entries) #-- Convenience path cc.path.gout = os.path.join(cc.path.gastronoom,self.path) self.vic = vic self.trans_in_progress = [] self.sphinx = sphinx cool_keys = os.path.join(cc.path.aux,'Input_Keywords_Cooling.dat') ml_keys = os.path.join(cc.path.aux,'Input_Keywords_Mline.dat') sph_keys = os.path.join(cc.path.aux,'Input_Keywords_Sphinx.dat') self.cooling_keywords = [line.strip() for line in DataIO.readFile(cool_keys) if line] self.mline_keywords = [line.strip() for line in DataIO.readFile(ml_keys) if line] self.sphinx_keywords = [line.strip() for line in DataIO.readFile(sph_keys) if line] DataIO.testFolderExistence(os.path.join(cc.path.gout,'data_for_mcmax')) self.trans_bools = [] self.mline_done = False self.cool_done = False self.cooling_molec_keys = ['ENHANCE_ABUNDANCE_FACTOR',\ 'ABUNDANCE_FILENAME',\ 'NUMBER_INPUT_ABUNDANCE_VALUES',\ 'KEYWORD_TABLE','MOLECULE_TABLE',\ 'ISOTOPE_TABLE'] self.no_ab_molecs = ['12C16O','13C16O','1H1H16O','p1H1H16O',\ '1H1H17O','p1H1H17O','1H1H18O','p1H1H18O'] #- Read standard input file with all parameters that should be included filename = os.path.join(cc.path.aux,'inputGASTRoNOoM.dat') self.standard_inputfile = DataIO.readDict(filename,\ comment_chars=['#','!']) self.skip_cooling = skip_cooling self.recover_sphinxfiles = recover_sphinxfiles self.cool_db = cool_db self.ml_db = ml_db self.sph_db = sph_db
def __init__(self,star_name,instrument_name,oversampling,\ code='GASTRoNOoM',path=None,intrinsic=1,path_linefit='',\ blend_factor=1.2): """ Initializing an instance of Instrument. @param star_name: The name of the star from Star.py @type star_name: string @param instrument_name: The name of the instrument (SPIRE or PACS) @type instrument_name: string @param oversampling: The instrumental oversampling, for correct convolution of the Sphinx output. @type oversampling: int @keyword code: The radiative transfer code used to model the data (default: 'GASTRoNOoM') @type code: string @keyword path: Output folder in the code's home folder. Used to locate eg PACS database. If None, no model info required (eg for line measurement matching/identification) (default: None) @type path: string @keyword intrinsic: Use the intrinsic Sphinx line profiles for convolving with the spectral resolution? Otherwise the beam convolved line profiles are used. (default: 1) @type intrinsic: bool @keyword path_linefit: The folder name for linefit results from Hipe (created by Pierre, assuming his syntax). The folder is located in $path_pacs$/$star_name$/. If no folder is given, no linefits are processed. (default: '') @type path_linefit: string @keyword blend_factor: The relative factor with respect to the intrinsic instrumental FWHM that is compared with the fitted Gaussian FWHM to determine whether an emission line may be blended. (default: 1.2) @type blend_factor: float """ self.path = path self.code = code self.star_name = star_name self.path_linefit = path_linefit self.instrument = instrument_name.lower() self.path_instrument = getattr(cc.path,'d%s'%self.instrument) self.intrinsic = intrinsic self.oversampling = int(oversampling) self.blend_factor = float(blend_factor) self.data_filenames = [] istar = DataIO.getInputData(keyword='STAR_NAME').index(star_name) #-- Set relevant velocities in cm/s self.c = 2.99792458e10 self.vlsr = float(DataIO.getInputData(keyword='V_LSR',rindex=istar))*10**5 if not self.path is None: pp = getattr(cc.path,self.code.lower()) DataIO.testFolderExistence(os.path.join(pp,self.path,'stars')) DataIO.testFolderExistence(os.path.join(pp,self.path,'stars',\ self.star_name)) self.readTelescopeProperties()
def __init__(self,star_name='model',inputfilename=None,\ path='codeJun2010',code='GASTRoNOoM'): """ Initializing an instance of PlottingSession. @keyword star_name: name of the star from Star.dat, use default only when never using any star model specific things (default: "model") @type star_name: string @keyword path: Output modeling folder in code home folder (default: 'codeJun2010') @type path: string @keyword inputfilename: name of inputfile that is also copied to the output folder of the plots, if None nothing is copied (default: None) @type inputfilename: string @keyword code: the modeling code (default: GASTRoNOoM) @type code: string """ self.inputfilename = inputfilename self.star_name = star_name self.star_index = DataIO.getInputData(path=cc.path.usr)\ .index(self.star_name) self.star_name_plots = DataIO.getInputData(path=cc.path.usr, keyword='STAR_NAME_PLOTS',\ remove_underscore=1,\ rindex=self.star_index) #-- Can't use convenience paths here through cc.path, because the # module is not code specific. Within a single pything session, there # may be multiple instances of PlottingSession self.path = path fn_mcm = os.path.join(cc.path.aux,'Mutable_Parameters_MCMax.dat') self.mutable_mcmax = [line[0] for line in DataIO.readFile(fn_mcm,delimiter=' ') if ''.join(line).strip()] self.mutable_mcmax = [line for line in self.mutable_mcmax if line[0] != '#'] fn_gas = os.path.join(cc.path.aux,'Mutable_Parameters_GASTRoNOoM.dat') self.mutable_gastronoom = [line[0] for line in DataIO.readFile(fn_gas,\ delimiter=' ') if ''.join(line).strip()] self.mutable_gastronoom = [line for line in self.mutable_gastronoom if line[0] != '#'] self.mutable = self.mutable_mcmax + self.mutable_gastronoom self.plot_id = 'plot_%.4i-%.2i-%.2ih%.2i-%.2i-%.2i' \ %(gmtime()[0],gmtime()[1],gmtime()[2],\ gmtime()[3],gmtime()[4],gmtime()[5]) self.code = code #-- Folder management and copying inputfile to plot output folder pout = os.path.join(getattr(cc.path,self.code.lower()),self.path,\ 'stars') pstar = os.path.join(pout,self.star_name) self.pplot = os.path.join(pstar,self.plot_id) for pp in [pout,pstar,self.pplot]: DataIO.testFolderExistence(pp) if self.inputfilename <> None: ipfn = os.path.split(self.inputfilename)[1] newf = os.path.join(self.pplot,ipfn) subprocess.call(['cp %s %s'%(self.inputfilename,newf)],shell=True)
def doChemistry(self,star): """ Running Chemistry. @param star: The parameter set for this session @type star: Star() """ print '***********************************' #- Create the input dictionary for this Chemistry run print '** Making input file for Chemistry' #-- Add the previous model_id to the list of new entries, so it does # not get deleted if replace_db_entry == 1. if self.model_id: self.new_entries.append(self.model_id) self.model_id = '' self.command_list = dict() # Bijzonder gevallen hier ipv in loop over orig # Dan is input_lines/command_list wat er in de database staat # input_lines = d if star['PERFORM_ROUTINE'] == 0: self.command_list['ROUTINE_RADIUS'] = 0 else: self.command_list['ROUTINE_RADIUS'] = star['ROUTINE_RADIUS'] #*star['R_STAR']*star.Rsun self.command_list['R_STAR'] = star['R_STAR']*star.Rsun #self.command_list['R_INNER_CHEM'] = star['R_INNER_CHEM']*\ #star['R_STAR']*star.Rsun #self.command_list['R_OUTER_CHEM'] = star['R_OUTER_CHEM']*\ #star['R_STAR']*star.Rsun self.command_list['REACTIONS_FILE'] = '"'+os.path.join(cc.path.csource,\ 'rates',star['REACTIONS_FILE'])+'"' self.command_list['SPECIES_FILE'] = '"'+os.path.join(cc.path.csource,\ 'specs',star['SPECIES_FILE'])+'"' self.command_list['FILECO'] = '"'+os.path.join(cc.path.csource,\ 'shielding',star['FILECO'])+'"' self.command_list['FILEN2'] = '"'+os.path.join(cc.path.csource,\ star['FILEN2'])+'"' add_keys = [k for k in self.standard_inputfile.keys() if not self.command_list.has_key(k)] [self.setCommandKey(k,star,star_key=k.upper(),\ alternative=self.standard_inputfile[k]) for k in add_keys] print '** DONE!' print '***********************************' #-- Check the Chemistry database if the model was calculated before modelbool = self.checkDatabase() #-- if no match found in database, calculate new model with new model id #-- if the calculation did not fail, add entry to database for new model if not modelbool: input_dict = self.command_list.copy() input_lines = [] orig = DataIO.readFile(self.inputfilename) for i,s in enumerate(orig): split = s.split() if s[0] == '!': input_lines.append(s) else: input_lines.append(" ".join(split[0:2])+' '+\ str(self.command_list[split[0]])) output_folder = os.path.join(cc.path.cout,'models',self.model_id) DataIO.testFolderExistence(output_folder) input_lines.append('OUTPUT_FOLDER = "' +\ output_folder+'/"') input_filename = os.path.join(cc.path.cout,'models',\ 'inputChemistry_%s.txt'%self.model_id) DataIO.writeFile(filename=input_filename,input_lines=input_lines) #subprocess.call(' '.join([cc.path.ccode,input_filename]),shell=True) subprocess.call(' '.join([os.path.join(cc.path.csource,'csmodel'),input_filename]),shell=True) # files die worden aangemaakt op einde, test of successvol testf1 = os.path.join(output_folder,'cscoldens.out') testf2 = os.path.join(output_folder,'csfrac.out') if os.path.exists(testf1) and os.path.exists(testf2) and \ os.path.isfile(testf1) and os.path.isfile(testf2): del self.db[self.model_id]['IN_PROGRESS'] self.db.addChangedKey(self.model_id) else: print '** Model calculation failed. No entry is added to ' + \ 'the database.' del self.db[self.model_id] self.model_id = '' if not self.single_session: self.db.sync() #- Note that the model manager now adds/changes MUTABLE input keys, #- which MAY be overwritten by the input file inputComboCode.dat print '***********************************'
def doCooling(self,star): """ Run Cooling. First, database is checked for retrieval of old model. @param star: The parameter set for this session @type star: Star() """ #-- Collect H2O and CO molecule definitions for inclusion in the # cooling inputfile. Also includes abundance_filename info for H2O if # requested if star.getMolecule('1H1H16O') <> None: h2o_dict = star.getMolecule('1H1H16O').makeDict() else: h2o_dict = Molecule('1H1H16O',45,45,648,50).makeDict() if star.getMolecule('12C16O') <> None: co_dict = star.getMolecule('12C16O').makeDict() else: co_dict = Molecule('12C16O',61,61,240,50).makeDict() #-- no abundance profiles should be possible for CO. if co_dict.has_key('MOLECULE_TABLE'): raise IOError('CO cannot be attributed a custom abundance ' + \ 'profile at this time.') #-- F_H2O is irrelevant if an abundance file is passed for oH2O if h2o_dict.has_key('MOLECULE_TABLE'): del self.command_list['F_H2O'] #-- Collect all H2O molecular information important for cooling molec_dict = dict([(k,h2o_dict[k]) for k in self.cooling_molec_keys if h2o_dict.has_key(k)]) #-- Check database: only include H2O extra keywords if # abundance_filename is present. CO can't have this anyway. model_bool = self.checkCoolingDatabase(molec_dict=molec_dict) #- Run cooling if above is False if not model_bool: DataIO.testFolderExistence(os.path.join(cc.path.gout,'models',\ self.model_id)) commandfile = ['%s=%s'%(k,v) for k,v in sorted(self.command_list.items()) if k != 'R_POINTS_MASS_LOSS'] + \ ['####'] + \ ['%s=%s'%(k,co_dict['MOLECULE'])] + \ ['%s=%s'%(k,h2o_dict[k]) for k in self.cooling_molec_keys + ['MOLECULE'] if h2o_dict.has_key(k)] + ['####'] if self.command_list.has_key('R_POINTS_MASS_LOSS'): commandfile.extend(['%s=%s'%('R_POINTS_MASS_LOSS',v) for v in self.command_list\ ['R_POINTS_MASS_LOSS']] + \ ['####']) filename = os.path.join(cc.path.gout,'models',\ 'gastronoom_' + self.model_id + '.inp') DataIO.writeFile(filename,commandfile) if not self.skip_cooling: self.execGastronoom(subcode='cooling',filename=filename) self.cool_done = True if os.path.isfile(os.path.join(cc.path.gout,'models',\ self.model_id,'coolfgr_all%s.dat'\ %self.model_id)): #-- Add the other input keywords for cooling to the H2O info. # This is saved to the db molec_dict.update(self.command_list) self.cool_db[self.model_id] = molec_dict self.cool_db.sync() else: print 'Cooling model calculation failed. No entry is added '+ \ 'to the database.' self.model_id = ''
def __init__(self,star_name,oversampling,path=None,redo_convolution=0,\ intrinsic=1,path_linefit=''): ''' Initializing an instance of Pacs(). @param star_name: Name of the star from Star.dat @type star_name: string @param oversampling: The PACS instrumental oversampling, for correct convolution of the Sphinx output] @type oversampling: int @keyword path: Output folder in the code's home folder. Used to locate the PACS database. If None, it is not used (eg for line measurement matching/identification) (default: None) @type path: string @keyword intrinsic: Use the intrinsic Sphinx line profiles for convolving with the spectral resolution? Otherwise the beam convolved line profiles are used. (default: 1) @type intrinsic: bool @keyword redo_convolution: if you want to do the convolution of the sphinx models regardless of what's already in the database. The pacs id will not change, nor the entry in the db, and the old convolved model will be copied to a backup (default: 0) @type redo_convolution: bool @keyword path_linefit: The folder name for linefit results from Hipe (created by Pierre, assuming his syntax). The folder is located in $path_pacs$/$star_name$/. If no folder is given, no linefits are processed. (default: '') @type path_linefit: string ''' super(Pacs,self).__init__(star_name=star_name,code='GASTRoNOoM',\ path_linefit=path_linefit,path=path,\ oversampling=oversampling,blend_factor=1.2,\ instrument_name='PACS',intrinsic=intrinsic) self.data_wave_list = [] self.data_flux_list = [] self.data_ordernames = [] self.data_orders = [] self.data_delta_list = [] self.redo_convolution = redo_convolution if not self.path is None: #-- Convenience path cc.path.gout = os.path.join(cc.path.gastronoom,self.path) #-- Check the path for the PACS database if a model folder is known db_path = os.path.join(cc.path.gout,'stars',self.star_name) if os.path.isdir(db_path): self.db_path = os.path.join(db_path,'GASTRoNOoM_pacs_models.db') self.db = Database.Database(self.db_path) DataIO.testFolderExistence(os.path.join(cc.path.gout,'stars',\ self.star_name,'PACS_results')) else: self.db = None self.db_path = None self.sphinx_prep_done = 0 self.readLineFit()
def __init__(self,star_name='model',inputfilename=None,\ path='',code='GASTRoNOoM',fn_add_star=1): """ Initializing an instance of PlottingSession. @keyword star_name: name of the star from Star.dat, use default only when never using any star model specific things (default: "model") @type star_name: string @keyword path: Output modeling folder in code home folder (default: '') @type path: string @keyword inputfilename: name of inputfile that is also copied to the output folder of the plots, if None nothing is copied (default: None) @type inputfilename: string @keyword code: the modeling code (default: GASTRoNOoM) @type code: string @keyword fn_add_star: Add the star name to the requested plot filename. Only relevant if fn_plt is given in a sub method. (default: 1) @type fn_add_star: bool """ self.inputfilename = inputfilename self.star_name = star_name self.star_index = DataIO.getInputData( path=cc.path.usr).index(star_name) self.star_name_plots = DataIO.getInputData(path=cc.path.usr, keyword='STAR_NAME_PLOTS',\ remove_underscore=1,\ rindex=self.star_index) #-- Can't use convenience paths here through cc.path, because the # module is not code specific. Within a single python session, there # may be multiple instances of PlottingSession if not path: print('Warning! %s model output folder not set.' % code) self.path = path fn_mcm = os.path.join(cc.path.aux, 'Mutable_Parameters_MCMax.dat') self.mutable_mcmax = [ line[0] for line in DataIO.readFile(fn_mcm, delimiter=' ') if ''.join(line).strip() ] self.mutable_mcmax = [ line for line in self.mutable_mcmax if line[0] != '#' ] fn_gas = os.path.join(cc.path.aux, 'Mutable_Parameters_GASTRoNOoM.dat') self.mutable_gastronoom = [line[0] for line in DataIO.readFile(fn_gas,\ delimiter=' ') if ''.join(line).strip()] self.mutable_gastronoom = [ line for line in self.mutable_gastronoom if line[0] != '#' ] self.mutable = self.mutable_mcmax + self.mutable_gastronoom self.plot_id = 'plot_%.4i-%.2i-%.2ih%.2i-%.2i-%.2i' \ %(gmtime()[0],gmtime()[1],gmtime()[2],\ gmtime()[3],gmtime()[4],gmtime()[5]) self.code = code #-- Folder management and copying inputfile to plot output folder pout = os.path.join(getattr(cc.path,self.code.lower()),self.path,\ 'stars') pstar = os.path.join(pout, self.star_name) self.pplot = os.path.join(pstar, self.plot_id) for pp in [pout, pstar]: DataIO.testFolderExistence(pp) self.fn_add_star = fn_add_star
def __init__(self,star_name='model',inputfilename=None,\ path='',code='GASTRoNOoM',fn_add_star=1): """ Initializing an instance of PlottingSession. @keyword star_name: name of the star from Star.dat, use default only when never using any star model specific things (default: "model") @type star_name: string @keyword path: Output modeling folder in code home folder (default: '') @type path: string @keyword inputfilename: name of inputfile that is also copied to the output folder of the plots, if None nothing is copied (default: None) @type inputfilename: string @keyword code: the modeling code (default: GASTRoNOoM) @type code: string @keyword fn_add_star: Add the star name to the requested plot filename. Only relevant if fn_plt is given in a sub method. (default: 1) @type fn_add_star: bool """ self.inputfilename = inputfilename self.star_name = star_name self.star_index = DataIO.getInputData(path=cc.path.usr).index(star_name) self.star_name_plots = DataIO.getInputData(path=cc.path.usr, keyword='STAR_NAME_PLOTS',\ remove_underscore=1,\ rindex=self.star_index) #-- Can't use convenience paths here through cc.path, because the # module is not code specific. Within a single python session, there # may be multiple instances of PlottingSession if not path: print('Warning! %s model output folder not set.'%code) self.path = path fn_mcm = os.path.join(cc.path.aux,'Mutable_Parameters_MCMax.dat') self.mutable_mcmax = [line[0] for line in DataIO.readFile(fn_mcm,delimiter=' ') if ''.join(line).strip()] self.mutable_mcmax = [line for line in self.mutable_mcmax if line[0] != '#'] fn_gas = os.path.join(cc.path.aux,'Mutable_Parameters_GASTRoNOoM.dat') self.mutable_gastronoom = [line[0] for line in DataIO.readFile(fn_gas,\ delimiter=' ') if ''.join(line).strip()] self.mutable_gastronoom = [line for line in self.mutable_gastronoom if line[0] != '#'] self.mutable = self.mutable_mcmax + self.mutable_gastronoom self.plot_id = 'plot_%.4i-%.2i-%.2ih%.2i-%.2i-%.2i' \ %(gmtime()[0],gmtime()[1],gmtime()[2],\ gmtime()[3],gmtime()[4],gmtime()[5]) self.code = code #-- Folder management and copying inputfile to plot output folder pout = os.path.join(getattr(cc.path,self.code.lower()),self.path,\ 'stars') pstar = os.path.join(pout,self.star_name) self.pplot = os.path.join(pstar,self.plot_id) for pp in [pout,pstar]: DataIO.testFolderExistence(pp) self.fn_add_star = fn_add_star
def __init__(self,path_gastronoom='runTest',vic=None,sphinx=0,\ replace_db_entry=0,cool_db=None,ml_db=None,sph_db=None,\ skip_cooling=0,recover_sphinxfiles=0,\ new_entries=[]): """ Initializing an instance of a GASTRoNOoM modeling session. A single cooling model and a given set of molecules and transitions are calculated here or are retrieved from the databases. @keyword path_gastronoom: modeling folder in GASTRoNOoM home (default: 'runTest') @type path_gastronoom: string @keyword vic: the vic manager for running sphinx models on VIC3 (default: None) @type vic: Vic() @keyword sphinx: Running Sphinx? (default: 0) @type sphinx: bool @keyword replace_db_entry: replace an entry in the databases with a newly calculated model with a new model id (e.g. if some general data not included in the inputfiles is changed) (default: 0) @type replace_db_entry: bool @keyword new_entries: The new model_ids when replace_db_entry is 1 of other models in the grid. These are not replaced! (default: []) @type new_entries: list[str] @keyword skip_cooling: Skip running cooling in case a model is not found in the database, for instance if it is already known that the model will fail (default: 0) @type skip_cooling: bool @keyword recover_sphinxfiles: Try to recover sphinx files from the disk in case they were correctly calculated, but not saved to the database for one reason or another. (default: 0) @type recover_sphinxfiles: bool @keyword cool_db: the cooling database (default: None) @type cool_db: Database() @keyword ml_db: the mline database (default: None) @type ml_db: Database() @keyword sph_db: the sphinx database (default: None) @type sph_db: Database() """ super(Gastronoom,self).__init__(code='GASTRoNOoM',\ path=path_gastronoom,\ replace_db_entry=replace_db_entry,\ new_entries=new_entries) #-- Convenience path cc.path.gout = os.path.join(cc.path.gastronoom, self.path) self.vic = vic self.trans_in_progress = [] self.sphinx = sphinx cool_keys = os.path.join(cc.path.aux, 'Input_Keywords_Cooling.dat') ml_keys = os.path.join(cc.path.aux, 'Input_Keywords_Mline.dat') sph_keys = os.path.join(cc.path.aux, 'Input_Keywords_Sphinx.dat') self.cooling_keywords = [ line.strip() for line in DataIO.readFile(cool_keys) if line ] self.mline_keywords = [ line.strip() for line in DataIO.readFile(ml_keys) if line ] self.sphinx_keywords = [ line.strip() for line in DataIO.readFile(sph_keys) if line ] DataIO.testFolderExistence(os.path.join(cc.path.gout, 'data_for_mcmax')) self.trans_bools = [] self.mline_done = False self.cool_done = False self.cooling_molec_keys = ['ENHANCE_ABUNDANCE_FACTOR',\ 'ABUNDANCE_FILENAME',\ 'NUMBER_INPUT_ABUNDANCE_VALUES',\ 'KEYWORD_TABLE','MOLECULE_TABLE',\ 'ISOTOPE_TABLE'] self.no_ab_molecs = ['12C16O','13C16O','1H1H16O','p1H1H16O',\ '1H1H17O','p1H1H17O','1H1H18O','p1H1H18O'] #- Read standard input file with all parameters that should be included filename = os.path.join(cc.path.aux, 'inputGASTRoNOoM.dat') self.standard_inputfile = DataIO.readDict(filename,\ comment_chars=['#','!']) self.skip_cooling = skip_cooling self.recover_sphinxfiles = recover_sphinxfiles self.cool_db = cool_db self.ml_db = ml_db self.sph_db = sph_db
def __init__(self,star_name,instrument_name,oversampling,absflux_err,\ code='GASTRoNOoM',path=None,intrinsic=1,path_linefit=''): """ Initializing an instance of Instrument. @param star_name: The name of the star from Star.py @type star_name: string @param instrument_name: The name of the instrument (SPIRE or PACS) @type instrument_name: string @param oversampling: The instrumental oversampling, for correct convolution of the Sphinx output. @type oversampling: int @param absflux_err: The absolute flux calibration uncertainty of the instrument. @type absflux_err: float @keyword code: The radiative transfer code used to model the data (default: 'GASTRoNOoM') @type code: string @keyword path: Output folder in the code's home folder. Used to locate eg PACS database. If None, no model info required (eg for line measurement matching/identification) (default: None) @type path: string @keyword intrinsic: Use the intrinsic Sphinx line profiles for convolving with the spectral resolution? Otherwise the beam convolved line profiles are used. (default: 1) @type intrinsic: bool @keyword path_linefit: The folder name for linefit results from Hipe (created by Pierre, assuming his syntax). The folder is located in $path_pacs$/$star_name$/. If no folder is given, no linefits are processed. (default: '') @type path_linefit: string """ self.path = path self.code = code self.star_name = star_name self.path_linefit = path_linefit self.instrument = instrument_name.lower() self.path_instrument = getattr(cc.path, 'd%s' % self.instrument) self.intrinsic = intrinsic self.absflux_err = absflux_err self.oversampling = int(oversampling) self.data_filenames = [] istar = DataIO.getInputData(keyword='STAR_NAME').index(star_name) #-- Set relevant velocities in cm/s self.c = 2.99792458e10 self.vlsr = DataIO.getInputData(keyword='V_LSR', rindex=istar) * 10**5 if self.path <> None: pp = getattr(cc.path, self.code.lower()) DataIO.testFolderExistence(os.path.join(pp, self.path, 'stars')) DataIO.testFolderExistence(os.path.join(pp,self.path,'stars',\ self.star_name))
def __init__(self,star_name='model',inputfilename=None,\ path='codeJun2010',code='GASTRoNOoM'): """ Initializing an instance of PlottingSession. @keyword star_name: name of the star from Star.dat, use default only when never using any star model specific things (default: "model") @type star_name: string @keyword path: Output modeling folder in code home folder (default: 'codeJun2010') @type path: string @keyword inputfilename: name of inputfile that is also copied to the output folder of the plots, if None nothing is copied (default: None) @type inputfilename: string @keyword code: the modeling code (default: GASTRoNOoM) @type code: string """ self.inputfilename = inputfilename self.star_name = star_name self.star_index = DataIO.getInputData(path=cc.path.usr)\ .index(self.star_name) self.star_name_plots = DataIO.getInputData(path=cc.path.usr, keyword='STAR_NAME_PLOTS',\ remove_underscore=1,\ rindex=self.star_index) #-- Can't use convenience paths here through cc.path, because the # module is not code specific. Within a single pything session, there # may be multiple instances of PlottingSession self.path = path fn_mcm = os.path.join(cc.path.aux, 'Mutable_Parameters_MCMax.dat') self.mutable_mcmax = [ line[0] for line in DataIO.readFile(fn_mcm, delimiter=' ') if ''.join(line).strip() ] self.mutable_mcmax = [ line for line in self.mutable_mcmax if line[0] != '#' ] fn_gas = os.path.join(cc.path.aux, 'Mutable_Parameters_GASTRoNOoM.dat') self.mutable_gastronoom = [line[0] for line in DataIO.readFile(fn_gas,\ delimiter=' ') if ''.join(line).strip()] self.mutable_gastronoom = [ line for line in self.mutable_gastronoom if line[0] != '#' ] self.mutable = self.mutable_mcmax + self.mutable_gastronoom self.plot_id = 'plot_%.4i-%.2i-%.2ih%.2i-%.2i-%.2i' \ %(gmtime()[0],gmtime()[1],gmtime()[2],\ gmtime()[3],gmtime()[4],gmtime()[5]) self.code = code #-- Folder management and copying inputfile to plot output folder pout = os.path.join(getattr(cc.path,self.code.lower()),self.path,\ 'stars') pstar = os.path.join(pout, self.star_name) self.pplot = os.path.join(pstar, self.plot_id) for pp in [pout, pstar, self.pplot]: DataIO.testFolderExistence(pp) if self.inputfilename <> None: ipfn = os.path.split(self.inputfilename)[1] newf = os.path.join(self.pplot, ipfn) subprocess.call(['cp %s %s' % (self.inputfilename, newf)], shell=True)