def read_galaxy_database(query,
filename,
username,
password,
simname,
data_request=0):
if data_request == 1:
mySims = np.array([(simname, 12.)])
con = sql.connect(username, password=password)
for sim_name, sim_size in mySims:
# print sim_name
myData = sql.execute_query(con, query)
# print myData
pickle_out = open(filename, 'wb')
pickle.dump(myData, pickle_out)
pickle_out.close()
elif data_request == 0:
pickle_in = open(filename, 'rb')
myData = pickle.load(pickle_in)
pickle_in.close()
return myData
def __init__(self, randomNumber, simulation, dataStorageLocation):
'''
The initialisation of this class initially will define all the constants that will be required during the module. These can be changed directly and then run the UpdateInformation module to update all the dependants. It also creates the dictionaries that will be used to store data during the processing. This initialisation requires the parameters:
- randomNumber: A random number used to limit the number of results queried from the database
- simulation: The simulation that the we are interested in querying
- dataStorageLocation: The location that the pickle files will be loaded from and saved to
'''
#Defining Values
self.ageUniverse = 13.799 # Age of the Universe used in Time Linking estimate gotten from
self.massPrecision = 0.05 # Mass Precision Used in Galaxy Matching
self.dataStoragePath = dataStorageLocation # The path to the storage for files that will be save and loaded
self.MinimumNumberInBin = 10 # The minimum number of values that need to be in a bin in order for it to be statistically signicant enough to take the median
#Defining all the Storage Tables
self.dataStorage = {} # Main Raw Data Storage
self.binningStorage = {} # Post Processing Storage for Binned Data
self.comparisonData = {} # Storage of Galaxies that have been matched
self.propertiesQueried = {
} # Storage of the properties stored for each DataSet
self.defaultQueries = {} # Storage of Default Queries
self.timeData = astropy.table.Table(
) # Storage for the Time Data (relation between redshift, snapshot numbers, lookbacktime and age of the universe)
self.timeReference = {
} # A Reference Dictionary used to get corresponding redshfit and lookback time for a given redshift
# DataBase Connection
self.con = sql.connect("scp763", password="******")
# PreInitialisation of Stored Queries
self.simName = simulation
self.randNum = randomNumber
self.generateQueries()
# Query Time Data from the Eagle Database to be used by the time linking module
# Get the data from the Eagle Database
snapShotData = sql.execute_query(self.con,
self.defaultQueries['TimeQuery'])
#Add the queried data to the storage Astropy Table self.timeData
for label in snapShotData.dtype.names:
self.timeData[label] = snapShotData[label]
del snapShotData, label
# Also calculate the corresping age of the universe at each snapshot and add it as a column
self.timeData[
'AgeOfUniverse'] = self.ageUniverse - self.timeData['LookBackTime']
# Creating a dictionary used for referenceing the snap shot to the redshift and lookbacktime
for SN, LB, z, t in zip(self.timeData['SnapNum'],
self.timeData['LookBackTime'],
self.timeData['Z'],
self.timeData['AgeOfUniverse']):
self.timeReference[SN] = [LB, z, t]
def __init__(self, ID, model='REFERENCE', run='L0100N1504'):
self.model = model_dict[model]
self.run = run
if isinstance(ID, int):
self.MainDescendantID = ID
#query to get other descendant info:
query = f'SELECT\
gal.Snapnum as snapnum,\
gal.GroupNumber as groupnum,\
gal.SubGroupNumber as subgroupnum,\
gal.TopLeafID as TopLeafID\
FROM\
{model_dict[model]+run}_Subhalo as gal\
WHERE\
gal.GalaxyID = {ID}'
result = sql.execute_query(con, query)
self.MainDescendantGroupNumber = result['groupnum']
self.MainDescendantSubGroupNumber = result['subgroupnum']
self.MainDescendantSnapNum = result['snapnum']
self.MainDescendantTopLeafID = result['TopLeafID']
else:
# is [GroupNumber,SubGroupNumber,SnapNum]
self.MainDescendantGroupNumber = ID[0]
self.MainDescendantSubGroupNumber = ID[1]
self.MainDescendantSnapNum = ID[2]
query = f'SELECT\
gal.GalaxyID as galaxyid,\
gal.TopLeafID as TopLeafID\
FROM\
{model_dict[model]+run}_Subhalo as gal\
WHERE\
gal.GroupNumber = {ID[0]} and\
gal.SubGroupNumber = {ID[1]} and\
gal.SnapNum = {ID[2]}'
result = sql.execute_query(con, query)
self.MainDescendantID = result['galaxyid']
self.MainDescendantTopLeafID = result['TopLeafID']
def __init__(self):
query = 'SELECT\
snap.Snapnum as snapnum,\
snap.Redshift as redshift,\
snap.LookbackTime as tlookback,\
snap.LumDistance as lumdistance\
FROM\
Snapshots as snap'
snapinfo = sql.execute_query(con, query)
self.Snapnum = snapinfo['snapnum']
self.Redshift = snapinfo['redshift']
self.LookbackTime = snapinfo['tlookback']
self.LumDistance = snapinfo['lumdistance']
def get_all_progenitors(self, mass_limit=1e9):
""" return mass, coordinates and redshift of all progenitors """
query = f'SELECT\
prog.GalaxyID as GalaxyID,\
prog.MassType_Star as mstar,\
prog.CentreOfPotential_x as x,\
prog.CentreOfPotential_y as y,\
prog.CentreOfPotential_z as z,\
prog.SnapNum as snapnum,\
prog.Redshift as redshift,\
prog.DescendantID as DescendantID,\
prog.LastProgID as LastProgID,\
prog.TopLeafID as TopLeafID\
FROM\
{self.model+self.run}_Subhalo as des,\
{self.model+self.run}_Subhalo as prog\
WHERE\
des.GalaxyID = {self.MainDescendantID} and\
des.SnapNum = {self.MainDescendantSnapNum} and\
prog.MassType_star > {mass_limit} and\
prog.GalaxyID between {self.MainDescendantID} and des.LastProgID'
result = sql.execute_query(con, query)
#identify main branch
mainbranch = result['TopLeafID'] == self.MainDescendantTopLeafID
#store all progeny off the main branch (we want these separate for a few reasons...)
self.ProgenitorIDs = result['GalaxyID'][~mainbranch]
self.ProgenitorStellarMass = result['mstar'][~mainbranch]
self.ProgenitorCoPs = np.dstack(
[result['x'], result['y'], result['z']])[0][~mainbranch]
self.ProgenitorSnapNums = result['snapnum'][~mainbranch]
self.ProgenitorRedshift = result['redshift'][~mainbranch]
self.ProgenitorDescendantID = result['DescendantID'][~mainbranch]
self.ProgenitorLastProgID = result['LastProgID'][~mainbranch]
self.ProgenitorTopLeafID = result['TopLeafID'][~mainbranch]
#store the Main Branch separately
self.MainBranchIDs = result['GalaxyID'][mainbranch]
self.MainBranchStellarMass = result['mstar'][mainbranch]
self.MainBranchCoPs = np.dstack(
[result['x'], result['y'], result['z']])[0][mainbranch]
self.MainBranchSnapNums = result['snapnum'][mainbranch]
self.MainBranchRedshift = result['redshift'][mainbranch]
self.MainBranchDescendantID = result['DescendantID'][mainbranch]
self.MainBranchLastProgID = result['LastProgID'][mainbranch]
self.MainBranchTopLeafID = result['TopLeafID'][mainbranch]
def query(username, password, query, outfile):
print('Connecting to EAGLE database...')
con = sql.connect(username, password=password)
print('Connected.')
print('Executing query...')
data = sql.execute_query(con, query)
out_data = {}
for name in data.dtype.names:
out_data[name] = data[name]
with open(outfile, 'w') as output:
pickle.dump(out_data, output)
output.close()
print('Dumped output to ', outfile)
def database_query(username,password,query,outfile):
import eagleSqlTools as sql
import pickle
print 'Connecting to EAGLE database...'
con = sql.connect(username, password=password)
print 'Connected.'
print 'Executing query...'
data = sql.execute_query(con, query)
out_data = {}
for name in data.dtype.names:
out_data[name] = data[name]
with open(outfile, 'w') as output:
pickle.dump(out_data,output)
output.close()
print 'Dumped output to ',outfile
def __init__(self,
snapPath=None,
snapBase=None,
fof=None,
sub=None,
db_user=None,
db_key=None,
subBoxSize=50. * U.kpc,
distance=3. * U.Mpc,
vpeculiar=0 * U.km / U.s,
rotation={'L_coords': (60. * U.deg, 0. * U.deg)},
ra=0. * U.deg,
dec=0. * U.deg,
print_query=False):
if snapPath is None:
raise ValueError('Provide snapPath argument to EAGLESource.')
if snapBase is None:
raise ValueError('Provide snapBase argument to EAGLESource.')
if fof is None:
raise ValueError('Provide fof argument to EAGLESource.')
if sub is None:
raise ValueError('Provide sub argument to EAGLESource.')
if db_user is None:
raise ValueError('Provide EAGLE database username.')
# optional dependencies for this source class
from eagleSqlTools import connect, execute_query
from pyread_eagle import EagleSnapshot
from Hdecompose.atomic_frac import atomic_frac
import h5py
snapNum = int(snapBase.split('_')[1])
volCode = normpath(snapPath).split(sep)[-2]
query = \
'SELECT '\
' sh.redshift as redshift, '\
' sh.CentreOfPotential_x as x, '\
' sh.CentreOfPotential_y as y, '\
' sh.CentreOfPotential_z as z, '\
' sh.Velocity_x as vx, '\
' sh.Velocity_y as vy, '\
' sh.Velocity_z as vz '\
'FROM '\
' {:s}_SubHalo as sh '.format(volCode) + \
'WHERE '\
' sh.Snapnum = {:d} '.format(snapNum) + \
' and sh.GroupNumber = {:d} '.format(fof) + \
' and sh.SubGroupNumber = {:d}'.format(sub)
if print_query:
print('-----EAGLE-DB-QUERY-----')
print(query)
print('-------QUERY-ENDS-------')
if db_key is None:
print('EAGLE database')
q = execute_query(connect(db_user, db_key), query)
redshift = q['redshift']
a = np.power(1 + redshift, -1)
cop = np.array([q[coord] for coord in 'xyz']) * a * U.Mpc
vcent = np.array([q['v' + coord] for coord in 'xyz']) * U.km / U.s
snapFile = join(snapPath, snapBase + '.0.hdf5')
with h5py.File(snapFile, 'r') as f:
h = f['RuntimePars'].attrs['HubbleParam']
subBoxSize = (subBoxSize * h / a).to(U.Mpc).value
centre = (cop * h / a).to(U.Mpc).value
eagle_data = EagleSnapshot(snapFile)
region = np.vstack(
(centre - subBoxSize, centre + subBoxSize)).T.flatten()
eagle_data.select_region(*region)
lbox = f['/Header'].attrs['BoxSize'] * U.Mpc / h
fH = f['/RuntimePars'].attrs['InitAbundance_Hydrogen']
fHe = f['/RuntimePars'].attrs['InitAbundance_Helium']
proton_mass = f['/Constants'].attrs['PROTONMASS'] * U.g
mu = 1 / (fH + .25 * fHe)
gamma = f['/RuntimePars'].attrs['EOS_Jeans_GammaEffective']
T0 = f['/RuntimePars'].attrs['EOS_Jeans_TempNorm_K'] * U.K
def fetch(att, ptype=0):
# gas is type 0, only need gas properties
tmp = eagle_data.read_dataset(ptype, att)
dset = f['/PartType{:d}/{:s}'.format(ptype, att)]
aexp = dset.attrs.get('aexp-scale-exponent')
hexp = dset.attrs.get('h-scale-exponent')
return np.array(tmp, dtype='f8') * np.power(a, aexp) \
* np.power(h, hexp)
code_to_g = f['/Units'].attrs['UnitMass_in_g'] * U.g
code_to_cm = f['/Units'].attrs['UnitLength_in_cm'] * U.cm
code_to_cm_s = f['/Units'].attrs['UnitVelocity_in_cm_per_s'] \
* U.cm / U.s
ng_g = fetch('GroupNumber')
particles = dict(
xyz_g=(fetch('Coordinates') * code_to_cm).to(U.kpc),
vxyz_g=(fetch('Velocity') * code_to_cm_s).to(U.km / U.s),
T_g=fetch('Temperature') * U.K,
hsm_g=(fetch('SmoothingLength') * code_to_cm).to(U.kpc) *
find_fwhm(WendlandC2Kernel().kernel))
rho_g = fetch('Density') * U.g * U.cm**-3
SFR_g = fetch('StarFormationRate')
Habundance_g = fetch('ElementAbundance/Hydrogen')
particles['mHI_g'] = (atomic_frac(redshift,
rho_g * Habundance_g /
(mu * proton_mass),
particles['T_g'],
rho_g,
Habundance_g,
onlyA1=True,
EAGLE_corrections=True,
SFR=SFR_g,
mu=mu,
gamma=gamma,
fH=fH,
T0=T0) * code_to_g).to(U.solMass)
mask = ng_g == fof
for k, v in particles.items():
particles[k] = v[mask]
particles['xyz_g'] -= cop
particles['xyz_g'][particles['xyz_g'] > lbox / 2.] -= lbox.to(U.kpc)
particles['xyz_g'][particles['xyz_g'] < -lbox / 2.] += lbox.to(U.kpc)
particles['vxyz_g'] -= vcent
super().__init__(distance=distance,
vpeculiar=vpeculiar,
rotation=rotation,
ra=ra,
dec=dec,
h=h,
**particles)
return
def DatabaseQuery(self,
title,
queryOrQueryTitle,
defaultQuery=False,
loadFromPickle=False,
convertToAstropyOnLoad=True):
'''
The aim of this module will be to query the EAGLE database, import this data into the python module and sort it for easy access for automation but also allowing for intuitive manual access. This moduel takes the following parameters:
- title: A title for the Data that is going to be queried (this will be the label of data in the storage dictionary)
- Query: This should either be a fully formed SQL query startiing with the word SELECT with no spaces beforehand or if the parameter defaultQuery is set to True a string stating the name of one of the defaul queries availble in the package.
- defaultQuery: This parameter controls whether the module is expecting a custon SQL query or will be using a defualt query stored in the module
- loadFromPickle: If this parameter is set to true the module will instead load the data from a previously saved pickle file and organise it as required
- convertToAstropyOnLoad: If this parameter is true the imported pickle file will be converted to a Astropy table (mainly used to stop incosistant length dictionaries being converted, as this would rasie and error)
'''
#Firstly we will test loadFromPickle to known whether there is a pickle file to be loaded or the database will need to be queried
if loadFromPickle:
# Firstly we need to check the data type of the imported data. This is only going to support data which is already in the astropy.table.table.Table format or in hte dict type which would then need to be sorted into the astropy.table.table.Table
# Loading the specified pickle file
queriedData = pickle.load(
open("{}{}.p".format(self.dataStoragePath, queryOrQueryTitle),
"rb"))
#Checking if the Pickle file is a astropy.table.table.Table type
if isinstance(queriedData, astropy.table.table.Table):
# Saving the astropy table to the central data storage
self.dataStorage[title] = queriedData
self.propertiesQueried[title] = queriedData.keys()
del queriedData
# Checking if the Pickle file is a dict type
elif isinstance(queriedData, dict):
if convertToAstropyOnLoad:
# We will continue to sort this data as if it were a query from the database with some debug timing
print(
'Imported Data File is in Diction Format \n Sorting Data into Astropy Table ...'
)
ts = time.time()
#Creation Of Table
dataTable = astropy.table.Table()
for label in queriedData.keys():
dataTable[label] = queriedData[label]
#Storing Data in Dictionary
self.dataStorage[title] = dataTable
self.propertiesQueried[title] = queriedData.dtypes.names
# Spare Variable Clean Up
del queriedData, dataTable, label
#Debug Timing Finalising
sortTime = time.time() - ts
t = datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")
log = '{} | Sort Time: {}s'.format(
t, round(sortTime, 2))
print(log)
del ts, sortTime, t, log
else:
self.dataStorage[title] = queriedData
self.propertiesQueried[title] = queriedData.keys()
del queriedData
#If it does not match the two supported formats return an error statement
else:
print(
"ERROR \n Chosen file does not match the supported formats. Please ensure the contents are either a Dictionary obeject or Astropy Table \n Aborting Function"
)
else:
# In this first section we will determine which query will be sent to the database by checking if a default query was selected
if defaultQuery:
# If a default query was selected we are grabbing a query from the dictionary stored in the class.
query = self.defaultQueries[queryOrQueryTitle]
else:
# If a default query was not selected we first test if the query has the appropriate start
if queryOrQueryTitle[:6] != "SELECT":
print(
"ERROR in query Formatting: \n Please ensure all queries begin with the phrase SELECT and that all commands are formatted in uppercase \n ABORTING QUERY"
)
return
else:
query = queryOrQueryTitle
# Now the query for the array is selected the data base will be sent the query. There is additional code around the query to keep track of how long the query is taking which is useful for when large datasets are requested
####################
# Debug Timing SetUp
print('{} | Querying Database ... '.format(
datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")))
ts = time.time()
# Query the Database
queriedData = sql.execute_query(self.con, query)
# Debug Timing Finalising
queryTime = time.time() - ts
t = datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")
log = '{} | Query Time: {}s'.format(t, round(queryTime, 2))
print(log)
del ts, queryTime, t, log
# Now the Database has been queried and the data has been stored in the variable queriedData, we are going to re sort this data to store it in a Astropy Table as this allows for better visualisation of the dataset when manually analysing the data
# Firstly We Create the Astropy table and we also include a debuging timer to ensure time is not being lost when sorting the data
####################
# Debug Timing SetUp
print('Sorting Data into Astropy Table ...')
ts = time.time()
if convertToAstropyOnLoad:
#Creation Of Table
dataTable = astropy.table.Table()
for label in queriedData.dtype.names:
dataTable[label] = queriedData[label]
#Storing Data in Dictionary
self.dataStorage[title] = dataTable
self.propertiesQueried[title] = queriedData.dtype.names
# Spare Variable Clean Up
del queriedData, dataTable, label
else:
self.dataStorage[title] = queriedData
#Debug Timing Finalising
sortTime = time.time() - ts
t = datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")
log = '{} | Sort Time: {}s'.format(t, round(sortTime, 2))
print(log)
del ts, sortTime, t, log
FOF.Group_R_Crit200 as r_vir \
FROM \
{0}_SubHalo as H, \
{0}_SubHalo as S, \
{0}_FOF as FOF \
WHERE \
H.GalaxyID = {1:.0f} \
and H.GroupID = FOF.GroupID \
and 0.0033*FOF.Group_R_Crit200 > ABS( H.CentreOfPotential_x - (S.CentreOfPotential_x - FLOOR((S.CentreOfPotential_x+{2:.0f})/ {5:.0f}))) \
and 0.0033*FOF.Group_R_Crit200 > ABS( H.CentreOfPotential_y - (S.CentreOfPotential_y - FLOOR((S.CentreOfPotential_y+{3:.0f})/ {5:.0f}))) \
and 0.0033*FOF.Group_R_Crit200 > ABS( H.CentreOfPotential_z - (S.CentreOfPotential_z - FLOOR((S.CentreOfPotential_z+{4:.0f})/ {5:.0f}))) \
and S.Snapnum = 28 \
and S.MassType_Star between 1E9 and 1E12'.format(
sim, gid, dx, dy, dz, box_size)
sats_info = sql.execute_query(con, normal_sat_query)
sat_len = len(sats_info["Sgid"])
# print(sat_len)
# retrieving SubGroupNumber and FoF for a satellite
fof_sub_query = \
'SELECT \
S.GalaxyID as gid, \
S.GroupNumber as fof, \
S.SubGroupNumber as sub \
FROM \
{0}_SubHalo as S \
WHERE \
S.GalaxyID = {1}' .format(sim, sats_info["Sgid"][sat_index])
fof_sub_info = sql.execute_query(con, fof_sub_query)
SH.GalaxyID as gid, \
SH.GroupNumber as fof,\
SH.SubGroupNumber as sub, \
SH.CentreOfPotential_x as copx, \
SH.CentreOfPotential_y as copy, \
SH.CentreOfPotential_z as copz, \
FOF.Group_R_Crit200 as r_vir \
FROM\
{0}_SubHalo as SH, \
{0}_FOF as FOF\
WHERE \
FOF.GroupID = SH.GroupID \
and SH.SnapNum = 28 \
and SH.MassType_DM > {1}".format(sim, host_mass)
host_ids = sql.execute_query(con, host_query)
# print(len(host_ids))
#
# if int(host_ids['sub'][host_index]) != 0:
# sys.exit()
# print((host_ids['gid'][0]))
t = time.time()
he_index = host_index
t1 = time.time()
# Handling hosts that are close to the sides of the box
SH.TopLeafID as TopLeafID, \
SH.DescendantID as DescendantID, \
SH.CentreOfMass_x as x, \
SH.CentreOfMass_y as y, \
AP.Mass_Star as stellar_mass, \
AP.SFR as sfr \
FROM \
%s_Aperture as AP, \
%s_SubHalo as SH \
WHERE \
SH.GalaxyID = AP.GalaxyID and \
AP.Mass_Star > 1e8 and \
AP.ApertureSize = 30 and \
SH.SnapNum = %i " % (sim[0], sim[0], snap.id)
galaxyData = sql.execute_query(connection, myQuery)
pylab.savetxt(
'../data/eagle_simulations/snap%02i.dat' % snap.id,
galaxyData,
fmt='%10i %10i %10i %10i %7.3f %7.3f %.3e %.1e',
header=
' GalaxyID LastProgID TopLeafID DescendantID x_cMpc y_cMpc stellarMass sfr'
)
galaxyData = galaxyData.reshape(-1)
### grabbing group data
myQuery = "SELECT \
FOF.GroupID as id, \
FOF.GroupCentreOfPotential_x as x, \
FOF.GroupCentreOfPotential_y as y, \
FOF.GroupMass as Mgroup, \
FROM \
{0}_SubHalo as H, \
{0}_SubHalo as S, \
{0}_FOF as FOF \
WHERE \
H.GalaxyID = {1:.0f} \
and H.GroupID = FOF.GroupID \
and 0.0033*FOF.Group_R_Crit200 > ABS( H.CentreOfPotential_x - (S.CentreOfPotential_x - FLOOR((S.CentreOfPotential_x+{2:.0f})/ {5:.0f}))) \
and 0.0033*FOF.Group_R_Crit200 > ABS( H.CentreOfPotential_y - (S.CentreOfPotential_y - FLOOR((S.CentreOfPotential_y+{3:.0f})/ {5:.0f}))) \
and 0.0033*FOF.Group_R_Crit200 > ABS( H.CentreOfPotential_z - (S.CentreOfPotential_z - FLOOR((S.CentreOfPotential_z+{4:.0f})/ {5:.0f}))) \
and S.Snapnum = 28 \
and S.MassType_Star between 1E8 and 1E12'.format(
sim, gid, dx, dy, dz, box_size)
#print( len(sats_info["Sgid"]))
sats_info = sql.execute_query(con, normal_sat_query)
print(sats_info)
try:
f = open("hostid_satnumber_rvir_33_{0}.txt".format(sim_box), "a")
f.write("{0} {1} {2} {3} {4} {5} {6}\n".format(gid, fof, sub, dx, dy, dz,
len(sats_info)))
f.close()
print(len(sats_info))
except TypeError as error:
pass
# f = open("hostid_satnumber_{0}.txt".format(sim_box), "a")
# f.write("{0:.0f} 0 \n".format(host_index))
# f.close()
SH.GalaxyID as gid, \
SH.GroupNumber as fof,\
SH.SubGroupNumber as sub, \
SH.CentreOfPotential_x as copx, \
SH.CentreOfPotential_y as copy, \
SH.CentreOfPotential_z as copz, \
FOF.Group_R_Crit200 as r_vir \
FROM\
{0}_SubHalo as SH, \
{0}_FOF as FOF\
WHERE \
FOF.GroupID = SH.GroupID \
and SH.SnapNum = 28 \
and SH.MassType_DM > {1}".format(sim, host_mass)
host_ids = sql.execute_query(con, host_query)
def edge_proximity(host_info, box_size): # copy this
offsetx = np.array([])
offsety = np.array([])
offsetz = np.array([])
gid = np.array([])
fof = np.array([])
sub = np.array([])
halfbox = box_size / 2
for host in host_info:
x, y, z = 0, 0, 0
r_vir = host['r_vir'] * 0.0033
if (host['copx'] - r_vir < 0):
x = halfbox
projection = []
for line in data:
words = line.split()
if words[0] == "#column":
continue
for i in range(5,len(words)):
projection.append(words[2])
if words[i] != "-1":
string += "(Mass = (SELECT MAX(Mass) FROM RefL0100N1504_Subhalo WHERE DescendantID = %s) AND DescendantID = %s) OR "%(words[i],words[i])
if words[i] == "-1":
string = string[:-3]
break
#print string
realstring.append(string)
string = "SELECT GroupNumber, SubGroupNumber, CentreOfPotential_x, CentreOfPotential_y, CentreOfPotential_z, HalfMassRad_DM, Mass, CentreOfMass_x, CentreOfMass_y, CentreOfMass_z, Velocity_x, Velocity_y, Velocity_z, GroupID FROM RefL0100N1504_Subhalo WHERE "
con = sql.connect("kbx631", password = "******")
indices = [41, '27', '28', 42, '27', '28', 70, '27', '28', 71, '27', '28', 111, '26', '28', 116, '26', '27', 118, '26', '28', 128, '26', '28', 129, '26', '26', 131, '26', '28', 136, '26', '28', 150, '26', '28', 163, '26', '28', 178, '26', '28', 230, '25', '27', 231, '25', '28', 237, '25', '27', 239, '25', '28', 241, '25', '27', 244, '25', '28', 269, '25', '27', 287, '25', '28', 288, '25', '28', 294, '25', '28', 298, '25', '28', 305, '25', '28', 320, '25', '28', 325, '25', '27', 328, '25', '28', 330, '25', '28', 356, '25', '26', 364, '24', '28', 367, '24', '26', 371, '24', '25', 377, '24', '27', 387, '24', '28', 389, '24', '28', 398, '24', '28', 399, '24', '27', 401, '24', '26', 402, '24', '28', 405, '24', '25', 406, '24', '27', 424, '24', '25', 429, '24', '26', 430, '24', '27', 431, '24', '28', 440, '24', '27', 442, '24', '25', 446, '24', '27', 449, '24', '28', 461, '24', '28', 464, '24', '26', 472, '24', '28', 479, '24', '28', 484, '24', '27', 485, '24', '27', 486, '24', '28', 508, '23', '28', 509, '23', '24', 511, '23', '26', 512, '23', '26', 521, '23', '28', 524, '23', '28', 529, '23', '28', 530, '23', '25', 532, '23', '26', 545, '23', '26', 546, '23', '26', 548, '23', '26', 551, '23', '27', 554, '23', '26', 555, '23', '25', 556, '23', '26', 561, '23', '26', 562, '23', '27', 563, '23', '27', 567, '23', '27', 571, '23', '25', 573, '23', '28', 574, '23', '28', 577, '23', '25', 581, '23', '25', 582, '23', '25', 587, '23', '25', 605, '23', '28', 607, '23', '26', 614, '23', '26', 619, '23', '26', 623, '23', '27', 624, '23', '27', 631, '23', '27', 633, '23', '26', 638, '23', '27', 640, '23', '25', 641, '23', '27', 643, '23', '27', 654, '23', '25', 681, '22', '28', 686, '22', '25', 688, '22', '28', 691, '22', '25', 695, '22', '27', 696, '22', '26', 701, '22', '26', 702, '22', '26', 706, '22', '25', 709, '22', '24', 716, '22', '25', 720, '22', '25', 722, '22', '25', 724, '22', '25', 729, '22', '25', 731, '22', '25', 732, '22', '25', 733, '22', '27', 737, '22', '25', 739, '22', '28', 740, '22', '26', 743, '22', '28', 744, '22', '27', 745, '22', '26', 746, '22', '28', 747, '22', '23', 751, '22', '25', 753, '22', '26', 754, '22', '26', 755, '22', '23', 757, '22', '28', 760, '22', '25', 763, '22', '25', 764, '22', '28', 766, '22', '27', 768, '22', '27', 770, '22', '27', 775, '22', '27', 785, '22', '27', 786, '22', '26', 793, '22', '28', 814, '22', '27', 816, '22', '28', 822, '22', '24', 826, '22', '27', 836, '22', '28', 838, '22', '26', 888, '21', '25', 889, '21', '26', 890, '21', '25', 893, '21', '24', 894, '21', '25', 898, '21', '23', 899, '21', '23', 900, '21', '27', 914, '21', '27', 916, '21', '23', 917, '21', '23', 918, '21', '28', 922, '21', '25', 924, '21', '24', 928, '21', '25', 934, '21', '25', 940, '21', '23', 941, '21', '25', 942, '21', '27', 952, '21', '23', 954, '21', '26', 956, '21', '26', 958, '21', '24', 960, '21', '26', 964, '21', '26', 965, '21', '23', 971, '21', '24', 973, '21', '27', 975, '21', '27', 979, '21', '26', 981, '21', '25', 982, '21', '24', 986, '21', '24', 990, '21', '26', 997, '21', '24', 1000, '21', '27', 1011, '21', '23', 1014, '21', '28', 1018, '21', '24', 1053, '20', '27', 1058, '20', '24', 1059, '20', '27', 1065, '20', '26', 1071, '20', '27', 1077, '20', '23', 1078, '20', '22', 1079, '20', '24', 1081, '20', '23', 1082, '20', '25', 1083, '20', '28', 1089, '20', '24', 1090, '20', '27', 1092, '20', '27', 1093, '20', '23', 1101, '20', '26', 1102, '20', '21', 1107, '20', '26', 1108, '20', '21', 1111, '20', '23', 1112, '20', '26', 1117, '20', '27', 1118, '20', '22', 1120, '20', '21', 1127, '20', '25', 1129, '20', '26', 1135, '20', '23', 1136, '20', '24', 1150, '20', '24', 1151, '20', '23', 1182, '19', '22', 1184, '19', '28', 1189, '19', '24', 1193, '19', '21', 1194, '19', '24', 1196, '19', '22', 1197, '19', '24', 1198, '19', '21', 1200, '19', '27', 1204, '19', '25', 1205, '19', '24', 1206, '19', '26', 1208, '19', '24', 1210, '19', '25', 1211, '19', '21', 1212, '19', '21', 1216, '19', '21', 1219, '19', '21', 1221, '19', '24', 1222, '19', '20', 1224, '19', '23', 1225, '19', '26', 1227, '19', '21', 1229, '19', '21', 1230, '19', '26', 1231, '19', '26', 1232, '19', '21', 1233, '19', '24', 1235, '19', '23', 1240, '19', '23', 1241, '19', '23', 1244, '19', '26', 1245, '19', '25', 1248, '19', '24', 1249, '19', '21', 1253, '19', '23', 1254, '19', '24', 1261, '19', '26', 1263, '19', '24', 1265, '19', '24', 1273, '19', '24']
for i in range(0,len(indices),3):
myQuery = realstring[indices[i]]
myData = sql.execute_query(con, myQuery)
print myQuery
#for j in range(len(myData)):
#print myData[j][13]
string2 = "SELECT GroupMass, GroupCentreOfPotential_x, GroupCentreOfPotential_y, GroupCentreOfPotential_z, Group_R_Crit2500 FROM RefL0100N1504_FOF WHERE GroupID = %i" %myData[0][13]
myData2 = sql.execute_query(con, string2)
myData2 = np.array([myData2])
#print myData2[0][0]
centre = np.array([myData2[0][1],myData2[0][2],myData2[0][3]])
Findmass(myData[0][0], myData[0][1], centre,i)
fil.close()
# in apertures etc. See again Stu's database reference paper for SQL examples of how to do that.
query = '''SELECT
gal.GroupNumber as gn,
gal.SubGroupNumber as sgn,
gal.Redshift as z,
gal.MassType_Star as stellarmass
FROM
%s_SubHalo as ref, -- You pick your z=0 descendant galaxy from the ref table
%s_Subhalo as gal -- Then the gal table holds its progenitors
WHERE
ref.GroupNumber = %i -- identify your halo
and ref.SubGroupNumber = 0 -- pick the central
and ref.SnapNum = 28 -- at z=0
and gal.GalaxyID between ref.GalaxyID and ref.TopLeafID -- this line picks out the tree
ORDER BY
gal.Redshift asc''' % (simlabel, simlabel,
groupnumbers[g])
data = sql.execute_query(con, query)
# The output is a dictionary which can be addressed using the names you gave in 'SELECT'
redshift = data['z']
stellarmass = data['stellarmass']
print redshift
print stellarmass
string = "SELECT GroupNumber, SubGroupNumber, CentreOfPotential_x, CentreOfPotential_y ,CentreOfPotential_z, GalaxyID FROM RefL0100N1504_Subhalo WHERE "
realstring = []
projection = []
for line in data:
words = line.split()
if words[0] == "#column":
continue
for i in range(3, len(words)):
#for i in range(5,len(words)):
projection.append(words[2])
if words[i] != "-1":
string += "GalaxyID = %s or " % (words[i])
if words[i] == "-1":
string = string[:-3]
break
realstring.append(string)
string = "SELECT GroupNumber, SubGroupNumber, CentreOfPotential_x, CentreOfPotential_y ,CentreOfPotential_z, GalaxyID FROM RefL0100N1504_Subhalo WHERE "
con = sql.connect("kbx631", password="******")
indices = [11, 13, 19, 24, 49, 64, 69]
#indices = [42]
n = 4
for i in range(3, len(indices)):
myQuery = realstring[indices[i]]
print myQuery
myData = sql.execute_query(con, myQuery)
centre = np.array([myData[0][2], myData[0][3], myData[0][4]])
PhaseDiagram_ReadEagle(myData[0][0], myData[0][1], centre)
n += 1
# xp = PhaseDiagram_ReadEagle(941030,0, centrep)
# y = PhaseDiagram_ReadEagle(1846,2, centre2)
def searchgals(xmin, xmax, ymin, ymax, zmin, zmax, strict=False):
mySim = ('RefL0100N1504', 100.)
con = sql.connect("dlokhorst", password="******")
myQuery = "SELECT " + "SH.GalaxyID, \
SH.StarFormationRate as SFR, \
SH.CentreOfPotential_x, \
SH.CentreOfPotential_y, \
SH.CentreOfPotential_z, \
SH.SubGroupNumber, \
SH.MassType_Star, \
SH.HalfMassProjRad_Gas, \
SH.HalfMassProjRad_Star \
FROM \
%s_SubHalo as SH \
WHERE \
SH.SnapNum = 28 and \
SH.CentreOfPotential_x >= %s and \
SH.CentreOfPotential_x <= %s and \
SH.CentreOfPotential_y >= %s and \
SH.CentreOfPotential_y <= %s and \
SH.CentreOfPotential_z >= %s and \
SH.CentreOfPotential_z <= %s and \
SH.MassType_Star > 0 " % ('RefL0100N1504', xmin, xmax, ymin,
ymax, zmin, zmax)
if strict:
myQuery = "SELECT " + "SH.GalaxyID, \
SH.StarFormationRate as SFR, \
SH.CentreOfPotential_x, \
SH.CentreOfPotential_y, \
SH.CentreOfPotential_z, \
SH.SubGroupNumber, \
SH.MassType_Star, \
SH.HalfMassProjRad_Gas, \
SH.HalfMassProjRad_Star \
FROM \
%s_SubHalo as SH \
WHERE \
SH.SnapNum = 28 and \
SH.CentreOfPotential_x >= %s and \
SH.CentreOfPotential_x <= %s and \
SH.CentreOfPotential_y >= %s and \
SH.CentreOfPotential_y <= %s and \
SH.CentreOfPotential_z >= %s and \
SH.CentreOfPotential_z <= %s and \
SH.MassType_Star > 0 and \
SH.StarFormationRate > 0.00001 " % (
'RefL0100N1504', xmin, xmax, ymin, ymax, zmin, zmax)
# and \
# SH.StarFormationRate > 0.00001
if verbose:
print myQuery
myData = sql.execute_query(con, myQuery)
xgal = myData['CentreOfPotential_x'][:] # cMpc
ygal = myData['CentreOfPotential_y'][:] # cMpc
#z = myData['CentreOfMass_z'][:]
mgal = myData['MassType_Star'][:] # M_solar
rhgas = myData['HalfMassProjRad_Gas'][:] # pkpc
rhstar = myData['HalfMassProjRad_Star'][:] # pkpc
return xgal, ygal, mgal, rhgas, rhstar
