def runStats(runf, props=[ 'star_mass', 'log_Teff', 'c_core_mass', 'total_mass_h1', 'total_mass_he4', 'log_L', 'log_R' ]): """Prints out relevant run information such as remnant C core and final mass. Args: runf (str): run folder to look in. props (list of str): h.header names to print out. default is ['star_mass', 'log_Teff', 'c_core_mass', 'total_mass_h1', 'total_mass_he4', 'log_L', 'log_R']. """ h = mr.MesaData(os.path.join(runf, "LOGS/history.data")) l = mr.MesaLogDir(os.path.join(runf, "LOGS")) print ("Version: {version_number}\nInitial Mass(Z): "\ "{initial_mass} ({initial_z})".format(**h.header_data)) print("Profiles found: {}".format(len(l.profile_numbers))) print("Models run: {}".format(h.data('model_number')[-1])) print("Initial zones: {}".format(max(h.data('num_zones')))) print("\nSimtime: {:10.9} Gyr\n".format(h.data('star_age')[-1] / 1e9)) print("{:20}{:<20} {:<20}\n".format('Prop', 'Initial', 'Final')) otp = "{:20}{:<20.5f} {:<20.5f}" for arg in props: print(otp.format(arg, h.data(arg)[0], h.data(arg)[-1])) if 'c_core_mass' in props: p = l.profile_data() zone = np.where(p.mass < p.c_core_mass)[0][0] print ("Final Mass and Radius of the Carbon Core: "\ "{:6.5e} Msun {:6.5e} cm".format(p.mass[zone], p.R[zone]*_Rs)) print("150km match head x_match: {:.6e}".format(p.R[zone] * _Rs / np.sqrt(2.))) return len(l.profile_numbers)
def plot(x): h = mr.MesaData(x) plt.plot(h.log_Teff, h.log_L) plt.gca().invert_xaxis() plt.xlabel('log Effective Temp') plt.ylabel('log Luminosity') plt.show()
def load_all_history(self): self.h = {} for k, PATH in self.path_dict.items(): self.h[k] = mr.MesaData(path.join(PATH, 'history.data')) self._h_keys = np.array([k for k in self.h.keys()]) self._h_M = np.array([float(k) for k in self._h_keys]) idx = self._h_M.argsort() self._h_keys = self._h_keys[idx] self._h_M = self._h_M[idx]
def evaluate_initial_grid(self): """Reads history files in a directory tree and creates a grid of parameters. Saves the grid to a file and creates a directory with .mod files. Parameters ---------- Returns ---------- """ if not os.path.exists(self.output_dir): os.mkdir(self.output_dir) print(f"Output directory created: {self.output_dir}") else: print(f"Output directory '{self.output_dir}' already exists.") i = 0 for log_dir in sorted(self.log_dirs): print(log_dir) initial_parameters = self.read_progenitor_name( os.path.basename(log_dir)) data = mesa.MesaData(os.path.join(log_dir, "history.data")) if data.center_h1[-1] < 1e-4: rgb_tip = self.find_rgb_tip(data) # model number, not index! default_model = rgb_tip // 10 * 10 + 10 for n in range(-self.number_of_minus_models, self.number_of_plus_models + 1): model_number = default_model + 10 * n model_name = f"model_{model_number:05d}.mod" if os.path.isfile(os.path.join(log_dir, model_name)): self.add_one_row(i, model_number, n, initial_parameters, data) shutil.copyfile( os.path.join(log_dir, model_name), os.path.join( self.output_dir, self.create_mod_name(os.path.basename(log_dir), n, model_number))) i += 1 else: print(f"{model_name} does not exist!") else: try: shutil.rmtree(log_dir) print(f"Deleted: {log_dir}") except OSError as e: print(f"Error: {log_dir} : {e.strerror}") print('') self.save_grid_to_file(self.output_file)
def graphing(): if os.getcwd() != answer1: os.chdir('..') gname = var2.get() if gname == "RR": h = mr.MesaData('mesa/star/test_suite/rsp_RR_Lyrae/LOGS/history.data') elif gname == "C": h = mr.MesaData('mesa/star/test_suite/rsp_Cepheid/LOGS/history.data') else: ProgressBar2.delete(1.0, END) ProgressBar2.insert(END, "Choose which star to graph") r1 = h.data(comboBox1.get()) r2 = h.data(comboBox2.get()) ProgressBar2.delete(1.0, END) ProgressBar2.insert(END, "Processing...") pl.plot(r1, r2) pl.xlabel(comboBox1.get()) pl.ylabel(comboBox2.get()) pl.gca().invert_xaxis() pl.show() ProgressBar2.delete(1.0, END) ProgressBar2.insert("Successful Graph")
def getWholeHistory(folders, xkey='log_Teff', ykey='log_L'): """returns aggregated history for a pair of keys from a list of sorted folders. Defaults to HR variables log_Teff and log_L """ xvals, yvals = np.array([]), np.array([]) for f in folders: h = mr.MesaData(os.path.join(f, "LOGS/history.data")) l = mr.MesaLogDir(os.path.join(f, "LOGS")) p = l.profile_data(profile_number=len(l.profile_numbers)) xrow, yrow = getHistProp(p, h, xkey, ykey) xvals = np.append(xvals, xrow) yvals = np.append(yvals, yrow) return xvals, yvals
def getClosestModel(modelNumber, workingDirectory): """Returns the MESA profile with the closest model number in a specified directory. Keyword arguments: modelNumber -- target/desired model number workingDirectory -- target directory """ print('Looking for the profile closest to model #' + str(modelNumber) + ' in ' + str(workingDirectory)) filenames = [] for root, dirs, files in os.walk(workingDirectory): for file in files: if file.endswith("profiles.index"): filenames.append(os.path.join(root, file)) profiles = [] # import files for file in filenames: i = mr.MesaProfileIndex(file) profiles.append(i) # find the closest model number - ugly but functional closest = 0 diff = 1e10 profilePath = '' j = 0 for index in profiles: values = index.model_numbers profileNums = index.profile_numbers k = 0 for i in values: if (abs(modelNumber - i) < diff): diff = abs(modelNumber - i) closest = i og = filenames[j] og = og[:-14] # put together the file name given the directory profilePath = og + 'profile' + str(profileNums[k]) + '.data' k += 1 j += 1 print('Actual model number: ' + str(closest)) print('Difference between target and actual model: ' + str(diff)) print('File path: ' + str(profilePath)) print('') # import target profile p = mr.MesaData(profilePath) return p
def read_history(self, log_dir: str, top_dir: str, dest_dir: Path = Path('.'), delete_file: bool = True, rename: bool = False, keep_tree: bool = False) -> mesa.MesaData: """Reads a MESA history file and returns a MesaData object. Parameters ---------- log_dir : str Log directory. top_dir : str Top directory. dest_dir : Path, optional Temporary directory for the required track. Default: Path('.'). delete_file : bool, optional If True delete the extracted track. The track is not deleted if 'keep_tree' is True. Default: True. rename : bool, optional If True it renames the history file to include information about the model contained in log_dir. keep_tree : bool, optional If True extract file with its directory structure (default ZipFile.extract() behaviour), otherwise extract file directly to 'dest_dir'. Default: False. Returns ---------- MesaData Evolutionary track (MESA history file) as MesaData object. """ if rename: history_name = f'history{log_dir[4:]}.data' else: history_name = 'history.data' if keep_tree: file_name = dest_dir.joinpath(top_dir, log_dir, history_name) else: file_name = dest_dir.joinpath(history_name) if not self.model_extracted(file_name): self.extract_history(log_dir, top_dir, dest_dir, rename, keep_tree) data = mesa.MesaData(str(file_name)) if delete_file and not keep_tree: file_name.unlink() return data
def centralCond(runf, prof_number, show=False, tstamp=True): """Plots central rho vs central t found in the profile. Args: runf (str): run folder to look in. prof_number (int): profile to plot. byM (bool): plot by mass (True) or by radius (False). show (bool): if True, returns the mpl.figure object. Returns: mpl.figure: plot of central rho vs central t. """ h = mr.MesaData(os.path.join(runf, "LOGS/history.data")) l = mr.MesaLogDir(os.path.join(runf, "LOGS")) profs = l.profile_numbers if prof_number > len(profs): print("Profile not found. ({}/{})".format(prof_number, len(profs))) else: print("Plotting T_c vs Rho_c. {}/{}.".format(prof_number, len(profs))) p = l.profile_data(profile_number=prof_number) rmax = l.profile_data(profile_number=1).photosphere_r fig = plt.figure(figsize=(7, 5)) layout = (1, 1) ax1 = plt.subplot2grid(layout, (0, 0), aspect="auto", adjustable='box-forced') plotCenterTRho(p, h, ax1) plt.tight_layout() if tstamp: ax1.annotate("{:0=8.7f}$\cdot 10^9$ yr".format( float(p.star_age) / 1e9), xy=(0.70, 0.08), xycoords='axes fraction', fontsize=10) tag = 'trhoc' if not os.path.exists("{}/png/".format(runf)): os.mkdir("{}/png/".format(runf, tag)) os.mkdir("{}/png/{}".format(runf, tag)) elif not os.path.exists("{}/png/{}/".format(runf, tag)): os.mkdir("{}/png/{}".format(runf, tag)) if show: return fig else: plt.savefig("{0}/png/{1}/{1}_{2:05}".format(runf, tag, p.model_number)) plt.close(fig) print("Wrote: {0}/png/{1}/{1}_{2:05}".format(runf, tag, p.model_number))
def read_evol_model(self, log_dir: str, top_dir: str, he4: float, dest_dir: Path = Path('.'), delete_file: bool = True, keep_tree: bool = False) -> mesa.MesaData: """Reads a single evolutionary model (a profile) and returns a MesaData object. Parameters ---------- log_dir : str Log directory. top_dir : str Top directory. he4 : float Central helium abundance of the required model. dest_dir : Path, optional Directory for the required model. Default: Path('.'). delete_file : bool, optional If True delete the extracted model. The model is not deleted if 'keep_tree' is True. Default: True. keep_tree : bool, optional If True extract file with its directory structure (default ZipFile.extract() behaviour), otherwise extract file directly to 'dest_dir'. Default: False. Returns ---------- MesaData Evolutionary model (MESA profile file) as MesaData object. """ if keep_tree: file_name = dest_dir.joinpath(top_dir, log_dir, self.evol_model_name(he4)) else: file_name = dest_dir.joinpath(self.evol_model_name(he4)) if not self.model_extracted(file_name): self.extract_evol_model(log_dir, top_dir, he4, dest_dir, keep_tree) data = mesa.MesaData(str(file_name)) if delete_file and not keep_tree: file_name.unlink() return data
def getMesa(profileFile): data = mr.MesaData(profileFile) logT = data.logT mass = data.mass logR = data.logR logRho = data.logRho logP = data.logP mass = mass * Msun T = np.power(10., logT) P = np.power(10., logP) / G radius = np.power(10., logR) rSun = 7e10 radius = radius * rSun rho = np.power(10., logRho) return T, mass, radius, rho, P
def evolution(param1, param2, filename): star = ms.MesaData(filename) plot1 = star.data(param1) if param2 == 'rhobar': mass = star.data('star_mass') mass = mass * 1.989e33 r = star.data('radius_cm') plot2 = 3 * mass / (4 * np.pi * r**3) else: plot2 = star.data(param2) if param1 == 'star_mass': plot1 = plot1 * 1.989e33 if param2 == 'star_mass': plot2 = plot2 * 1.989e33 plt.plot(plot1, plot2) plt.xlabel(param1) plt.ylabel(param2)
def getMesaEnt2(profileFile): data = mr.MesaData(profileFile) logT = data.logT mass = data.mass mass = mass * Msun logP = data.logP logR = data.logR logRho = data.logRho P = np.power(10., logP) / G rho = np.power(10., logRho) # dm = np.zeros(len(mass)) # for i in range(0,len(mass)-1) : # dm[i] = mass[i] - mass[i+1] # dm[len(mass)-1] = mass[len(mass)-1] ent = np.divide(P, np.power(rho, gamma)) return ent
def getMesaEnt(profileFile): data = mr.MesaData(profileFile) logT = data.logT mass = data.mass mass = mass * Msun logP = data.logP logR = data.logR T = np.power(10., logT) P = np.power(10., logP) / G dm = np.zeros(len(mass)) for i in range(0, len(mass) - 1): dm[i] = mass[i] - mass[i + 1] dm[len(mass) - 1] = mass[len(mass) - 1] ent = R * (5. / 2. + np.log( np.power(k * T, 2.5) / P / h / h / h * np.power(2. * math.pi * mpart, 1.5))) return ent, dm
def make_HR(direc, numTracks): for i in range(1, numTracks + 1): #profilefile = direc + "/i"+str(i).zfill(3)+"_profiles.index" # profilefile = direc + "profiles.index" # prof_info = np.loadtxt(profilefile,skiprows=1) # print "how many lines?", prof_info.size, profilefile # if prof_info.size < 4: # continue # modnum = prof_info[:,0] # profnum = prof_info[:,2] # firstpoint = np.int(modnum[profnum==2][0])-1 history_file = "history.data" star = ms.MesaData(file_name=direc) effectiveT = star.data("log_Teff") logL = star.data("log_L") plt.plot(effectiveT, logL, 'k-', linewidth=2) #for profile in profnum: # if np.mod(profile,2) == 0: # index_num = np.int(modnum[profnum == profile][0]) - 1 # print index_num # plt.plot(np.log10(effectiveT[index_num]),logL[index_num],'kd') plt.gca().invert_xaxis()
#print(root,file) m = re.search('profile(.+?).data', file) if m: modelno = m.group(1) #print(modelnos) modelnos += [modelno] if file.startswith('history'): dirs = os.path.join(root, file) #print(dirs) #print(natsort.natsorted(dirs,reverse=True)) h = mr.MesaData(dirs) Log_Teff_theo = h.log_Teff Log_L_theo = h.log_L Log_g_theo = h.log_g #mask = Log_Teff_lower < Log_Teff_theo and Log_Teff_upper > Log_Teff_theo histno = h.model_number histnos += [histno] histnos = np.array(histnos) for i in range(0, len(Log_Teff_theo)): mask1 = Log_Teff_lower < Log_Teff_theo[ i] and Log_Teff_upper > Log_Teff_theo[ i] and Log_L_lower < Log_L_theo[ i] and Log_L_upper > Log_L_theo[
action='store_true', default=False) args = parser.parse_args() if not (args.indata): parser.error('No indata supplied. Add "-i mesadata.dat", for example.') import matplotlib.pyplot as plt from astropy.io import ascii from astropy.table import Table import numpy as np import mesa_reader as mr import astropy.constants as c R_SUN_CGS = c.R_sun.cgs.value prof = mr.MesaData(args.indata) #prof = ascii.read(args.indata, header_start=4, data_start=5, format='basic', guess=False) #print prof.colnames # plot something if we want to if args.plot: fig = plt.figure() ax = fig.add_subplot(111) ax.plot(prof.data('logRho'), prof.data('logP'), '-', color='black', lw=2) fig.savefig('P_vs_Rho.png') # mass fraction of each of the elements we wish to track mf_els = np.empty([len(args.els), len(prof.logR)]) for i in np.arange(0, len(args.els)): mf_els[i] = prof.data(args.els[i])
# ~plt.axvline(0.0, c='k', label=r'$\alpha = 2.0$') # ~plt.subplots_adjust(bottom = 0.13) # ~plt.title(string_met) # ~lgnd = plt.legend(loc='best', fontsize=12) # ~plt.xlabel(r'$\rm \Delta_{\alpha}$', fontsize=16) # ~plt.ylabel(r'$\rm \Delta_{color}$', fontsize=16) # ~plt.show() # ~plt.close() # ~kill ######################################################################## ######################################################################## string_mass = 'M075' string_met = 'Z00025' h1 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/' + string_mass + '/scatter_test/' + string_met + '/history_fid.data') col1, mag1, mp1 = cut2(h1) h2 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/' + string_mass + '/scatter_test/' + string_met + '/history_m1sigma.data') col2, mag2, mp2 = cut2(h2) h3 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/' + string_mass + '/scatter_test/' + string_met + '/history_p1sigma.data') col3, mag3, mp3 = cut2(h3) plt.figure() if string_met == 'Z00015': h4 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/' + string_mass + '/scatter_test/' + string_met +
def getMaxRadiusProfile(workingDirectory): """Returns the profile with the biggest radius in a directory. Keyword arguments: workingDirectory -- target directory """ import os import mesa_reader as mr from heapq import nlargest import numpy as np filenames = [] for root, dirs, files in os.walk(workingDirectory): for file in files: if file.endswith("history.data"): filenames.append(os.path.join(root, file)) # for each file, go in and correct that quotation mark error # replace 10.14-2019 with 10.14-2019" for file in filenames: s = open(file).read() s = s.replace('10.14-2019 ', '10.14-2019"') f = open(file, 'w') f.write(s) f.close() # for each file, read it into a variable based on which log folder it's in hBRExists = False hARExists, hRExists = False, False htSBExists, htlgTExists = False, False hCExists, hFExists, hLExists = False, False, False for file in filenames: if 'before_remove' in file: hBR = mr.MesaData(file) hBRExists = True elif 'after_remove' in file: hAR = mr.MesaData(file) hARExists = True elif 'remove' in file: hR = mr.MesaData(file) hRExists = True elif 'to_si_burn' in file: htSB = mr.MesaData(file) htSBExists = True elif 'to_lgT_9.9' in file: htlgT = mr.MesaData(file) hlgTExists = True elif 'convert' in file: hC = mr.MesaData(file) hCExists = True elif 'finish' in file: hF = mr.MesaData(file) hFExists = True else: hL = mr.MesaData(file) hLExists = True # frankenstein the data together because MESA is MESA hModels = [] hRadius = [] if hBRExists: hRadius.append(hBR.log_R) hModels.append(hBR.model_number) if hRExists: hRadius.append(hR.log_R) hModels.append(hR.model_number) if hARExists: hRadius.append(hAR.log_R) hModels.append(hAR.model_number) if htSBExists: hRadius.append(htSB.log_R) hModels.append(htSB.model_number) if htlgTExists: hRadius.append(htlgT.log_R) hModels.append(htlgT.model_number) if hCExists: hRadius.append(hC.log_R) hModels.append(hC.model_number) # these are behaving weirdly # if hFExists: # hRadius.append(hF.log_R) # hModels.append(hF.model_number) if hLExists: hRadius.append(hL.log_R) hModels.append(hL.model_number) # find the model number for when the radius is at its maximum maxValues = [] maxModelNumbers = [] # find the biggest 5 in each history file for x in range(len(hRadius)): data = hRadius[x] maxValues.append(nlargest(1, data)) index = nlargest(1, range(len(data)), key=lambda idx: data[idx]) maxModelNumbers.append(hModels[x][index]) print(maxValues) print(maxModelNumbers) print('-----') print(max(maxValues)) modelNumber = int(maxModelNumbers[np.argmax(maxValues)]) print(modelNumber) # import desired profile # find all profile.index files filenames = [] for root, dirs, files in os.walk(workingDirectory): for file in files: if file.endswith("profiles.index"): filenames.append(os.path.join(root, file)) profiles = [] # import files for file in filenames: i = mr.MesaProfileIndex(file) profiles.append(i) return getClosestModel(modelNumber, workingDirectory)
#!/usr/bin/env python import mesa_reader as mr import matplotlib.pyplot as plt import matplotlib import numpy as np import sys cgsLsun = 3.848 * (10**33) palette = plt.get_cmap('viridis') history = [] for i in range(1, len(sys.argv)): history.append(mr.MesaData(str(sys.argv[i]))) # HR # for all stars for i in range(len(history)): lab = str(history[i]) plt.plot(history[i].log_Teff, history[i].log_L, color=palette(i / len(history)), ls='-', linewidth=2, label=lab) # anotation hit_ZAMS = False # for all timesteps in a star for j in range(len(history[i].star_age)): nucpercent = 10**(history[i].log_Lnuc[j]) / 10**(history[i].log_L[j])
def run_support(self, inlist, check_age): """ Helper function for running MESA. Args: inlist (str): Inlist to run. check_age (bool): Check whether the output model has the desired max_age. """ # to-do: implement option to store terminal # output in a log file self.remove_file('inlist') self.remove_file('restart_photo') copy2(inlist, 'inlist') ma = MesaAccess() self.model_name = ma['save_model_filename'] self.profile_name = ma['filename_for_profile_when_terminate'] try: self.history_name = ma['star_history_name'] except KeyError: self.history_name = 'history.data' if(self.pause): ma['pause_before_terminate'] = True else: ma['pause_before_terminate'] = False if(self.pgstar): ma['pgstar_flag'] = True else: ma['pgstar_flag'] = False self.remove_file(self.model_name) self.remove_file(self.profile_name) start_time = datetime.datetime.now() if(os.path.isfile('star')): print('Running', inlist) subprocess.call('./star') else: print('You need to build star first!') sys.exit() end_time = datetime.datetime.now() run_time = str(end_time - start_time) self.run_time = run_time micro_index = run_time.find('.') if(check_age): if(os.path.isfile(self.profile_name)): md = mr.MesaData(self.profile_name) star_age = md.star_age max_age = ma['max_age'] if(star_age < max_age): print(42 * '%') print('Star age is {:.2E}, while max age is {:.2E}' .format(star_age, max_age)) print('Failed to complete', inlist, 'after {} h:mm:ss'.format(run_time[:micro_index])) print(42 * '%') self.convergence = False else: print(42 * '%') print('Evolving the star took:', '{} h:mm:ss'.format(run_time[:micro_index])) print(42 * '%') self.convergence = True else: print(42 * '%') print('Failed to complete', inlist, 'after {} h:mm:ss'.format(run_time[:micro_index])) print(42 * '%') self.convergence = False else: if(os.path.isfile(self.model_name)): print(42 * '%') print('Evolving the star took:', '{} h:mm:ss'.format(run_time[:micro_index])) print(42 * '%') self.convergence = True else: print(42 * '%') print('Failed to complete', inlist, 'after {} h:mm:ss'.format(run_time[:micro_index])) print(42 * '%') self.convergence = False
def main(): print("In main analysis") run_dir = "/home/vishal/UMassD/sem2/astro_phy/project/runs" os.chdir(run_dir) cmd = 'find set_* -iname final.mod' results = os.popen(cmd).read().split('\n') #print(results) count = 1 masses = [] Zs = [] all_data = [] fe_core_z1 = [] # z=0.0001 fe_core_z2 = [] # z=0.001 fe_core_z3 = [] # z=0.01 fe_core_z4 = [] # z=0.1 si_core_z1 = [] # z=0.0001 si_core_z2 = [] # z=0.001 si_core_z3 = [] # z=0.01 si_core_z4 = [] # z=0.1 initial_mass_z1 = [] initial_mass_z2 = [] initial_mass_z3 = [] initial_mass_z4 = [] for paths in results: if paths == "": continue print(paths) count += 1 model_name = paths.split('/')[-2] mass = float(re.findall( 'M_[0-9.]+', model_name)[0].split('_')[-1]) # this is a string masses.append(mass) print("mass:" + str(mass)) z = float(re.findall('Z_[0-9.]+', model_name)[0].split('_')[-1]) # this is a string print("z:" + str(z)) Zs.append(z) # read the history.data file and extract the Fe, Si mass. LOG_name = 'LOGS_finish/' data_path = paths.split('/')[-3] + "/" + paths.split('/')[-2] #pdb.set_trace() d = mr.MesaData(data_path + "/LOGS_finish/history.data") fe_core_mass = d.data('fe_core_mass')[-1] si_core_mass = d.data('si_core_mass')[-1] all_data.append((mass, z, fe_core_mass, si_core_mass)) #pdb.set_trace() if (z == 0.0001): fe_core_z1.append(fe_core_mass) si_core_z1.append(si_core_mass) initial_mass_z1.append(mass) elif (z == 0.001): fe_core_z2.append(fe_core_mass) si_core_z2.append(si_core_mass) initial_mass_z2.append(mass) elif (z == 0.01): fe_core_z3.append(fe_core_mass) si_core_z3.append(si_core_mass) initial_mass_z3.append(mass) elif (z == 0.1): fe_core_z4.append(fe_core_mass) si_core_z4.append(si_core_mass) initial_mass_z4.append(mass) ######################################################################## # Plot for Fe core and Si shell mass after the ms_to_ccsn models pdb.set_trace() # Plot the results: plt.figure(1) plt.subplot(2, 2, 1) plt.scatter(initial_mass_z1, fe_core_z1, marker='^') plt.scatter(initial_mass_z1, si_core_z1, marker='s') #plt.scatter(initial_mass_z1,np.log10(fe_core_z1)) plt.title('z=0.0001') #plt.xlabel('Initial Progenitor($M_\odot\$)') plt.ylabel('Core Mass($M_{\odot}$)') plt.subplot(2, 2, 2) plt.scatter(initial_mass_z2, fe_core_z2, marker='^') plt.scatter(initial_mass_z2, si_core_z2, marker='s') #plt.scatter(initial_mass_z2,np.log10(fe_core_z2)) plt.title('z=0.001') #plt.xlabel('Initial Progenitor($M_\odot\$)') #plt.ylabel('Fe Core($M_\odot\$)') plt.subplot(2, 2, 3) plt.scatter(initial_mass_z3, fe_core_z3, marker='^') plt.scatter(initial_mass_z3, si_core_z3, marker='s') #plt.scatter(initial_mass_z3,np.log10(fe_core_z3)) plt.title('z=0.01') plt.xlabel('Main Sequence Mass($M_{\odot}$)') plt.ylabel('Core Mass($M_{\odot}$)') plt.subplot(2, 2, 4) plt.scatter(initial_mass_z4, fe_core_z4, marker='^') plt.scatter(initial_mass_z4, si_core_z4, marker='s') #plt.scatter(initial_mass_z4,np.log10(fe_core_z4)) plt.title('z=0.1') plt.xlabel('Main Sequence Mass($M_{\odot}$)') #plt.ylabel('Fe Core($M_\odot\$)') plt.figlegend(['Fe Core', 'Si Shell']) plt.savefig('Fe_core_vs_initial_mass_log10.png') plt.show() ######################################################################## # All the Fe core vs Initial mass model: pdb.set_trace() all_fe_core = fe_core_z1 + fe_core_z2 + fe_core_z3 + fe_core_z4 all_si_core = si_core_z1 + si_core_z2 + si_core_z3 + si_core_z4 all_initial_mass = initial_mass_z1 + initial_mass_z2 + initial_mass_z3 + initial_mass_z4 plt.figure(2) plt.scatter(initial_mass_z1, fe_core_z1, marker='^', color="gray", alpha=0.25) plt.scatter(initial_mass_z2, fe_core_z2, marker='^', color="gray", alpha=0.5) plt.scatter(initial_mass_z3, fe_core_z3, marker='^', color="gray", alpha=0.75) plt.scatter(initial_mass_z4, fe_core_z4, marker='^', color="gray", alpha=1.0) plt.legend(["0.0001", "0.001", "0.01", "0.1"], title="Metallicity") plt.xlabel('Main Sequence Mass($M_{\odot}$)') plt.ylabel('Core Mass($M_{\odot}$)') plt.show() ########################################################################### # Pickle the data up: pdb.set_trace() all_data = [all_fe_core, all_si_core] pickle.dump(all_data, open('pickle_data.p', 'w'))
def main(): parser = argparse.ArgumentParser() parser.add_argument("-D", "--dir", nargs='+', help="directory containing data files", type=str) parser.add_argument("--HR", help="plot an HR diagram", action='store_true') parser.add_argument("-f", "--filename", help="filename for the plots to be produced", type=str) parser.add_argument("--PDF", help="produce PDFs of the plots", action='store_true') # parser.add_argument("-H", "--heatmap", help="plot heatmaps for alpha, beta, and gamma", action='store_true') args = parser.parse_args() # assign various physical constants as global variables assign_const() # set up some plotting stuff fig = plt.figure(figsize=(12, 8)) # plt.style.use('fast') plt.style.use('Solarize_Light2') palette = plt.get_cmap('magma') vir = plt.get_cmap('viridis') # filename handling if args.filename: # custom file name filename = args.filename else: # or just concatinate all the directory names filename = ''.join(args.dir) # make our history list if args.dir: history = [] for i in range(len(args.dir)): # pick up the data from MESA files # history.append(mr.MesaLogDir(log_path=args.dir[i], history_file='history_' + args.dir[i] + '.data')) history.append( mr.MesaData(args.dir[i] + '/history_' + args.dir[i] + '.data')) # create our legend labels hist_lab = gen_hist_labels(history) # find the interesting profile indices # profs = gen_profs(history, args.dir) # create our profile labels # prof_lab = gen_prof_lab(profs) # hurtsburger and rustal if args.HR: for i in range(len(history)): # make actual plot plt.plot(history[i].log_Teff, history[i].log_L, color=vir(i / len(history)), ls='-', linewidth=2, label=hist_lab[i]) # add ZAMS anotation hit_ZAMS = False # for all timesteps in a star for j in range(len(history[i].star_age)): nucpercent = 10**(history[i].log_Lnuc[j]) / 10**( history[i].log_L[j]) if nucpercent > 0.900 and hit_ZAMS == False and history[ i].star_age[j] > 50.0: plt.scatter(history[i].log_Teff[j], history[i].log_L[j], c="#E0115F", s=10) plt.annotate( str(round(history[i].star_age[j])) + " yr " + str(round(history[i].radius[j], 2)) + " $R_{\odot}$", (history[i].log_Teff[j], history[i].log_L[j])) hit_ZAMS = True # make the plot plt.title("HR Diagram: " + filename) plt.legend() plt.gca().invert_xaxis() plt.ylabel('log($L$) [$L_{\odot}$]') plt.xlabel('log($T_{eff}$) [K]') plt.savefig(filename + ".png", dpi=400) if args.PDF: plt.savefig(filename + ".pdf") plt.clf()
def useful_profiles(dirname): histnos = [] modelnos = [] profnos = [] filtered = [] #filtered1 = [] #filtered2 = [] #filtered3 = [] profarray = [] dire = mr.MesaLogDir(dirname) for root, dirs, files in sorted(os.walk(dirname)): for file in files: if file.startswith('profile') and file.endswith( '.data'): #and os.path.exists(file)==True: #print(root,file) m = re.search('profile(.+?).data', file) if m: modelno = m.group(1) #print(modelnos) modelnos += [modelno] if file.startswith('history'): dirs = os.path.join(root, file) #print(dirs) #print(natsort.natsorted(dirs,reverse=True)) h = mr.MesaData(dirs) Log_Teff_theo = h.log_Teff Log_L_theo = h.log_L Log_g_theo = h.log_g #mask = Log_Teff_lower < Log_Teff_theo and Log_Teff_upper > Log_Teff_theo histno = h.model_number histnos += [histno] histnos = np.array(histnos) for i in range(0, len(Log_Teff_theo)): mask1 = Log_Teff_lower < Log_Teff_theo[ i] and Log_Teff_upper > Log_Teff_theo[ i] and Log_L_lower < Log_L_theo[ i] and Log_L_upper > Log_L_theo[ i] and Log_g_lower < Log_g_theo[ i] and Log_g_upper > Log_g_theo[i] filtered += [mask1] filtered = np.array(filtered) array = histnos[0] array_filtered = array[filtered] # for j in filtered: # if j == True: profiles = [] for i in modelnos: #i = int(i) p = dire.profile_data(profile_number=i) profno = p.model_number #print('Trues:') for number in array_filtered: #print(number) #for l in range(1,len(array_filtered)): if profno == number: print(i) #models = 'profile{}-freqs.data'.format(i) profiles.append(i) #print(models) #profnos += [profno] profiles return profiles
def onedir(fname): Log_Teff_obs = 3.839 #Log_L_obs = 1.340 Log_g_obs = 3.6 Log_Teff_obs_unc = 0.007 #Log_L_obs_unc = 0.0065 Log_g_obs_unc = 0.1 n = 3 Log_Teff_ns = n*Log_Teff_obs_unc #Log_L_ns = n*Log_L_obs_unc Log_g_ns = n*Log_g_obs_unc Log_Teff_lower = Log_Teff_obs - Log_Teff_ns Log_Teff_upper = Log_Teff_obs + Log_Teff_ns #Log_L_lower = Log_L_obs - Log_L_ns #Log_L_upper = Log_L_obs + Log_L_ns Log_g_upper = Log_g_obs + Log_g_ns Log_g_lower = Log_g_obs - Log_g_ns radial_funda = 6.8980 #radial_first = 8.9606 #l = 10 #radial_unc = l* 0.05 #radial_funda_lower = radial_funda - radial_unc #radial_funda_upper = radial_funda + radial_unc #radial_first_upper = radial_first + radial_unc #radial_first_lower = radial_first - radial_unc frequencies = [] frequency_dirs = [] frequency_roots = [] temp = [] dires = [] test_result = [] logg_dires = [] diffsndirs = [] minimum = [] for root, dirs, files in sorted(os.walk(fname)): logdirs = os.path.join(root) dires += [logdirs] for file in files: if file.startswith('history'): #print(os.path.join(root,file)) direcs = os.path.join(root,file) rooties = os.path.join(root) #print(natsort.natsorted(dirs,reverse=True)) h = mr.MesaData(direcs) mass = h.initial_mass model = h.model_number index = h.star_age > 2.0e7 noms_model = model[index] noms_logg = h.log_g[index] logg_dir = [noms_logg, noms_model, rooties] logg_dires.append(logg_dir) noms_Teff = h.log_Teff[index] noms_L = h.log_L[index] test_result = np.zeros((len(noms_model),3)) #rint(test_result) for i in range(0,len(noms_model)): test_result[i][0] = noms_model[i] test_result[i][1] = noms_logg[i] test_result[i][2] = noms_Teff[i] plt.plot(noms_Teff, noms_logg, '-',label='M=%s' %mass) if file.startswith('profile') and file.endswith('.data'): profiledirs = os.path.join(root,file) pnum = re.search('profile(.+?).data', profiledirs) if pnum: pnums = pnum.group(1) profiles_indir = mr.MesaLogDir(fname) pr = profiles_indir.profile_data(profile_number=pnums) pr_modelnos = pr.model_number if pr_modelnos == noms_model[0]: cutoff = pnums if file.endswith('freqs.dat'): gyredirs = os.path.join(root,file) gyreroots = os.path.join(root) fnum = re.search('profile(.+?)-freqs.dat', gyredirs) if fnum: fnums = fnum.group(1) if int(cutoff) <= int(fnums): #print(fnums) #print(gyredirs) freqs = gyr.readmesa(gyredirs) frequencies += [freqs] frequency_dirs += [gyredirs] frequency_roots += [gyreroots] allfreqs = [freqs ,gyredirs,gyreroots] temp.append(allfreqs) profiles = [] differs = [] temp3 = [] minValue = None for i in range(0,len(temp)): if size(temp[i][0]) ==1: continue if temp[i][0][0][1] == 1 and temp[i][0][1][1] == 2: #print('hej') succesfull_profiles = temp[i][1] profile_directories = temp[i][2] difference = np.abs(temp[i][0][0][4]-radial_funda) #print(difference) #difference_next = np.abs(temp[i+1][0][0][4]-radial_funda) currentValue = difference if minValue == None: minValue = currentValue else: minValue = min(minValue, currentValue) temp2 = [succesfull_profiles, difference] diffsndirs.append(temp2) profiles.append(profile_directories) differs.append(difference) minimum = differs.index(minValue) minimum_profile = diffsndirs[minimum] gnum = re.search('profile(.+?)-freqs.dat', minimum_profile[0]) if gnum: gnums = gnum.group(1) profiledata = mr.MesaLogDir(fname) p = profiledata.profile_data(profile_number=gnums) teff = p.Teff #print(teff) logteff = np.log10(teff) lmodel = p.photosphere_L logl = np.log10(lmodel) modelno_profile = p.model_number entry = np.where(logg_dires[0][1]== modelno_profile) best_logg = logg_dires[0][0][entry] plt.plot(logteff,best_logg,'k.', MarkerSize = 15) """ results_final = [] for root, dirs, files in sorted(os.walk('/home/janne/Gunter_project/44_tau/example_3ms/')): for dire in dirs: plt.figure(dire) dires = os.path.join(root,dire) #print(dires) results = petersen_plot(dires) results_final.append(results) #print(results) results #print(logteff) #alllogteffs.append(logteffs) #plt.plot([alllogteffs[i][0],alllogteffs[i][-1]],[working_logg_dires[0], working_logg_dires[-1]],'k--') """ # set axis labels xlabel(r'$\logT_{eff}$') ylabel(r'$\log(g)$') legend() plt.gca().invert_xaxis() plt.gca().invert_yaxis() plt.rcParams.update({'font.size': 20}) #PLOT ERRORBOX: plt.plot([Log_Teff_lower, Log_Teff_upper, Log_Teff_upper, Log_Teff_lower, Log_Teff_lower], [Log_g_lower, Log_g_lower, Log_g_upper, Log_g_upper, Log_g_lower], 'r-.', alpha=0.5, linewidth=3) return best_logg,logteff
def evaluate_initial_grid(grid_dir, output): """Reads history files in a directory tree and saves parameters to a single file. Parameters ---------- grid_dir : str Path to the directory with history files. output : str The name of output file. Returns ---------- None """ history_files = glob.glob(grid_dir + '/history*') n = len(history_files) # model_number's type should be int64, but there is an issue with # formatting pandas output for integers grid = np.zeros(n, dtype= \ [('m_i', 'float64'), \ ('rot', 'float64'), \ ('z', 'float64'), \ ('y', 'float64'), \ ('fh', 'float64'), \ ('fhe', 'float64'), \ ('fenv', 'float64'), \ ('mlt', 'float64'), \ ('sc', 'float64'), \ ('reimers', 'float64'), \ ('blocker', 'float64'), \ ('turbulence', 'float64'), \ ('m', 'float64'), \ ('model_number', 'float64'), \ ('log_Teff', 'float64'), \ ('log_L', 'float64'), \ ('age', 'float64'), \ ('m_core', 'float64')]) for i, track in enumerate(history_files): print(track) initial_parameters = read_progenitor_name(os.path.basename(track)) data = mesa.MesaData(track) if data.center_h1[-1] < 1e-4: rgb_tip = find_rgb_tip(data) grid['m_i'][i] = initial_parameters['m'] grid['rot'][i] = initial_parameters['rot'] grid['z'][i] = initial_parameters['z'] grid['y'][i] = initial_parameters['y'] grid['fh'][i] = initial_parameters['fh'] grid['fhe'][i] = initial_parameters['fhe'] grid['fenv'][i] = initial_parameters['fenv'] grid['mlt'][i] = initial_parameters['mlt'] grid['sc'][i] = initial_parameters['sc'] grid['reimers'][i] = initial_parameters['reimers'] grid['blocker'][i] = initial_parameters['blocker'] grid['turbulence'][i] = initial_parameters['turbulence'] grid['m'][i] = data.star_mass[rgb_tip] grid['model_number'][i] = data.model_number[rgb_tip] grid['log_Teff'][i] = data.log_Teff[rgb_tip] grid['log_L'][i] = data.log_L[rgb_tip] grid['age'][i] = data.star_age[rgb_tip] grid['m_core'][i] = data.he_core_mass[rgb_tip] else: os.remove(track) print("Deleted!") print('') save_grid_to_file(grid, output)
def main(): print("In main analysis") run_dir = "/home/vishal/UMassD/sem2/astro_phy/project/runs" os.chdir(run_dir) cmd = 'find set_* -iname final.mod' results = os.popen(cmd).read().split('\n') cmd2 = 'find shock_* -iname LOGS_part5' results2 = os.popen(cmd2).read().split('\n') #print(results) count = 1 masses = [] Zs = [] all_data = [] fe_core_z1 = [] # z=0.0001 fe_core_z2 = [] # z=0.001 fe_core_z3 = [] # z=0.01 fe_core_z4 = [] # z=0.1 si_core_z1 = [] # z=0.0001 si_core_z2 = [] # z=0.001 si_core_z3 = [] # z=0.01 si_core_z4 = [] # z=0.1 initial_mass_z1 = [] initial_mass_z2 = [] initial_mass_z3 = [] initial_mass_z4 = [] final_rem_masses_z1 = [] final_rem_masses_z2 = [] final_rem_masses_z3 = [] final_rem_masses_z4 = [] corrs_mass_z1 = [] corrs_mass_z2 = [] corrs_mass_z3 = [] corrs_mass_z4 = [] tot_ran = 0 G = 6.67408e-11 M_sol = 1.98e+30 for paths in results: if paths == "": continue print(paths) count += 1 model_name = paths.split('/')[-2] mass = float(re.findall( 'M_[0-9.]+', model_name)[0].split('_')[-1]) # this is a string masses.append(mass) print("mass:" + str(mass)) z = float(re.findall('Z_[0-9.]+', model_name)[0].split('_')[-1]) # this is a string print("z:" + str(z)) Zs.append(z) # read the history.data file and extract the Fe, Si mass. LOG_name = 'LOGS_finish/' data_path = paths.split('/')[-3] + "/" + paths.split('/')[-2] #pdb.set_trace() d = mr.MesaData(data_path + "/LOGS_finish/history.data") fe_core_mass = d.data('fe_core_mass')[-1] si_core_mass = d.data('si_core_mass')[-1] all_data.append((mass, z, fe_core_mass, si_core_mass)) #pdb.set_trace() if (z == 0.0001): fe_core_z1.append(fe_core_mass) si_core_z1.append(si_core_mass) initial_mass_z1.append(mass) elif (z == 0.001): fe_core_z2.append(fe_core_mass) si_core_z2.append(si_core_mass) initial_mass_z2.append(mass) elif (z == 0.01): fe_core_z3.append(fe_core_mass) si_core_z3.append(si_core_mass) initial_mass_z3.append(mass) elif (z == 0.1): fe_core_z4.append(fe_core_mass) si_core_z4.append(si_core_mass) initial_mass_z4.append(mass) for paths in results2: if paths == "": continue print(paths) count += 1 model_name = paths.split('/')[1] mass = float(re.findall( 'M_[0-9.]+', model_name)[0].split('_')[-1]) # this is a string print("mass:" + str(mass)) z = float(re.findall('Z_[0-9.]+', model_name)[0].split('_')[-1]) # this is a string print("z:" + str(z)) try: l = mr.MesaLogDir(paths) pl = l.profile_data() except: print("Not able to read data from " + paths) continue M_in = pl.data('mass') * M_sol R_in = pl.data('radius_cm') * 10**-2 vel_esc_sq = 2 * G * (M_in / R_in) vel_sq = (pl.data('vel_km_per_s') * 10**3)**2 a = vel_sq[-200:-1] < vel_esc_sq[-200:-1] try: mass_indx = np.where(a == True)[0][0] except: print("issues") continue rem_mass = pl.data('mass')[-200:-1][mass_indx] # solar masses tot_ran += 1 if (z == 0.0001): final_rem_masses_z1.append(rem_mass) corrs_mass_z1.append(mass) elif (z == 0.001): final_rem_masses_z2.append(rem_mass) corrs_mass_z2.append(mass) elif (z == 0.01): final_rem_masses_z3.append(rem_mass) corrs_mass_z3.append(mass) elif (z == 0.1): final_rem_masses_z4.append(rem_mass) corrs_mass_z4.append(mass) #pdb.set_trace() for indx, m in enumerate(initial_mass_z1): if m in corrs_mass_z1: plt.scatter(m, fe_core_z1[indx], marker='^', color='blue', alpha=0.25) plt.scatter(m, si_core_z1[indx], marker='s', color='orange', alpha=0.25) for indx, m in enumerate(initial_mass_z2): if m in corrs_mass_z2: plt.scatter(m, fe_core_z2[indx], marker='^', color='blue', alpha=0.5) plt.scatter(m, si_core_z2[indx], marker='s', color='orange', alpha=0.5) for indx, m in enumerate(initial_mass_z3): if m in corrs_mass_z3: plt.scatter(m, fe_core_z3[indx], marker='^', color='blue', alpha=0.75) plt.scatter(m, si_core_z3[indx], marker='s', color='orange', alpha=0.75) for indx, m in enumerate(initial_mass_z4): if m in corrs_mass_z4: plt.scatter(m, fe_core_z4[indx], marker='^', color='blue', alpha=1.0) plt.scatter(m, si_core_z4[indx], marker='s', color='orange', alpha=1.0) #plt.legend(['Si Shell']) #plt.scatter(corrs_mass_z1,final_rem_masses_z1,color='red',alpha=0.25) plt.scatter(corrs_mass_z2, final_rem_masses_z2, color='red', alpha=0.5) plt.scatter(corrs_mass_z3, final_rem_masses_z3, color='red', alpha=0.75) pdb.set_trace() plt.legend(['Fe Core', 'Si Shell']) #plt.scatter(corrs_mass_z4,final_rem_masses_z4,color='red',alpha=1.0) #plt.legend(['Z=0.001','Z=0.01']) #plt.legend(['Bound mass']) plt.xlabel('Main Sequence Mass($M_{\odot}$)') plt.ylabel('Core Mass($M_{\odot}$)') plt.show()
def buildStar(profileFile="profile15.data", makePlot=False): data = mr.MesaData(profileFile) logT = data.logT mass = data.mass logR = data.logR logRho = data.logRho logP = data.logP Hfrac = data.x_mass_fraction_H dlogTdlogP = (logT[1:] - logT[:-1]) / (logP[1:] - logP[:-1]) dlogTdlogP = np.append(np.array([dlogTdlogP[0]]), dlogTdlogP) R = 1e1**logR mtot = mass.max() print 'mtot = ' + str(mtot) maxR = R.max() rho = 1e1**logRho if (makePlot): plt.clf() plt.semilogy(R, 1e1**logRho, lw=2, color="blue") meanRho = mtot * mSun / (4. * math.pi / 3. * (maxR * rSun)**3) print 'mean density = ' + str(meanRho) # cutoffRho = 10.0*meanRho cutoffRho = 0.5 print 'cutoff density = ' + str(cutoffRho) boolArray = rho < cutoffRho nboolArray = np.logical_not(boolArray) massCentral = 0. logRCentral = -9. if (any(nboolArray)): massCentral = mass[nboolArray].max() logRCentral = logR[nboolArray].max() mass = mass[boolArray] logR = logR[boolArray] logT = logT[boolArray] logRho = logRho[boolArray] logP = logP[boolArray] dlogTdlogP = dlogTdlogP[boolArray] Hfrac = Hfrac[boolArray] R = R[boolArray] R = 1e1**logR pipe = subprocess.Popen("./hydro", stdin=subprocess.PIPE, stdout=subprocess.PIPE) #pipe = subprocess.Popen("./hydro", stdin=subprocess.PIPE) input_string = [] input_string.append("{0:12.10E} {1:12.10E}\n".format( massCentral, 1e1**logRCentral)) input_string.append("{0}\n".format(R.size)) for m, lgr, lgrho, lgT, lgP, dlTdlP, Xfrac in zip(mass, logR, logRho, logT, logP, dlogTdlogP, Hfrac)[::-1]: input_string.append( "{0:12.10E} {1:12.10E} {2:12.10E} {3:12.10E} {4:12.10E} {5:12.10E} {6:12.10E}\n" .format(m, lgr, lgrho, lgT, lgP, dlTdlP, Xfrac)) output_string = pipe.communicate("".join(input_string))[0] #pipe.communicate( "".join(input_string))[0] print output_string mcore, rcore = np.genfromtxt(io.BytesIO(output_string), max_rows=1, unpack=True) print "core mass: {0}, core radius = {1}".format(mcore, rcore) m, r, rho, T, p, Xout = np.genfromtxt(io.BytesIO(output_string), skip_header=2, unpack=True) print "maxR: {0}, Rmax = {1}".format(maxR, r.max()) boolArray = filterMonotonicity(rho) # for dens,temp,g in zip( rho, T,gamma): # print dens, temp, g if (makePlot): plt.semilogy(r, rho, ls="dashed", lw=3, color="green") plt.savefig("test.pdf") return mcore, rcore, m[boolArray], r[boolArray], rho[boolArray], T[ boolArray], Xout[boolArray]
#----------------------------------------------------------------------- ### comparison to isochrone #### #----------------------------------------------------------------------- Age = np.log10(13.32e9) distance = 0 Abs = 0 # ~met1 = -1.95 met1 = -2.0 met2 = -1.75 met3 = -1.5 string_mass = 'M075' string_met = 'scatter_test' htest1 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/'+string_mass+'/'+string_met+'/history_a1938.data') coltest1,magtest1, mptest1 = cut2(htest1) # htest1bis = mr.MesaData('/home/david/codes/data/GC_mixing_length/initial_mesa_dir/LOGS/history_a1938bis.data') # coltest1bis,magtest1bis, mptest1bis = cut2(htest1bis) htest2 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/'+string_mass+'/'+string_met+'/history_z00045.data') coltest2,magtest2, mptest2 = cut2(htest2) htest3 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/'+string_mass+'/'+string_met+'/history_z000142.data') coltest3,magtest3, mptest3 = cut2(htest3) htest4 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/'+string_mass+'/'+string_met+'/history_m080.data') coltest4,magtest4, mptest4 = cut2(htest4) # ~htest5 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/'+string_mass+'/'+string_met+'/history_a1888.data') # ~coltest5,magtest5, mptest5 = cut2(htest5) # ~htest6 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/'+string_mass+'/'+string_met+'/history_a1988.data') # ~coltest6,magtest6, mptest6 = cut2(htest6) # ~htest7 = mr.MesaData('/home/david/codes/Analysis/GC_mixing_length/catalogs/'+string_mass+'/'+string_met+'/history_a1838.data') # ~coltest7,magtest7, mptest7 = cut2(htest7)
def Main(): if (len(sys.argv) == 1): print "" print "Please include the 'history.data' file:" print " python XRayFreq.py history.data" print "" print "python XRayFreq.py -h : Help." print "" return if (sys.argv[1] == "-h"): PrintHelp() return print "" print "Getting the MESA data..." print "" # Load the "history.data" file and store it in "h" using Mesa_reader capabilities h = mr.MesaData(sys.argv[1]) # Retrieve the star age (in hours) and save it in "time" array time = h.data('star_age_hr') # Retrieve the luminosity lumi = h.data('log_L') # lumi=h.data('net_energy'); if (len(sys.argv) == 3) and (sys.argv[2] == "-t"): DoTemp(h.data('log_Teff'), time, h.data('star_mass')) return #Find the peaks Peaks = [] Peak_Times = [] Valleys = [] Valley_Times = [] Averages_In = [] Peaks, Peak_Times, Valleys, Valley_Times, Averages_In = FindPeaks( lumi, time) if (len(sys.argv) == 3) and (sys.argv[2] == "-d"): DrawData(time, lumi, Peaks, Peak_Times, Valleys, Valley_Times, "draw") if (len(sys.argv) == 3) and (sys.argv[2] == "-p"): DrawData(time, lumi, Peaks, Peak_Times, Valleys, Valley_Times, "print") #Peak_Times = Peak_Times[0:4] print "Number of peaks = ", len(Peak_Times) print "Peak times [hr]:" print Peak_Times print "Average Peak Luminosity = ", Averages_In[0] print "Average Valley Luminosity = ", Averages_In[1] print "Average Rise Time = ", Averages_In[2] print "Average Fall Time = ", Averages_In[3] time_period = FindPeakFrequency(Peak_Times) frequency = 1 / time_period print "" print "Time period = ", time_period, " [hr]" print "Frequency = ", frequency, " [1 / hr]" print "" if (len(sys.argv) == 3) and (sys.argv[2] == "-s"): SaveData(time, lumi, Peak_Times, Peaks) if (len(sys.argv) == 3) and (sys.argv[2] == "-f"): SaveFreqs(frequency, time_period, len(Peaks), h.data('star_mass'), Averages_In, "FrequencyData.txt")