def populatemap(self,n=None):
t0=self.cat.snap[0][2]
self.lbt=t0-[self.cat.snap[snap][2] for snap in self.snapshotindex]
indices_tree(self.cat,self.snapshotindex[0],self.snapshotindex[-1])
for snapshotnum in self.snapshotindex[1:]: #fill the halis dictionary at all snapshots after snapshot 0 with the index numbers of the parents of the snapshot 0 halos
self.halis[snapshotnum]=indices_tree(self.cat,0,snapshotnum,self.halis[0])
massmap=np.zeros([len(self.halis[0]),len(self.snapshotindex)])
pbar=ProgressBar()
for snapshotnum in pbar(self.snapshotindex):
for massmaprow, halindexnum in enumerate(self.halis[snapshotnum]): #massmap rows are halos. massmap columns are snapshots (each at a specific redshift). This loop populates the massmap by putting each halo's mass at the given redshift in the corresponding row and column.
if halindexnum<0: #If the parent ID is negative, the halo doesn't exist yet, so keep its mass at 0.
continue
else:
massmap[massmaprow,snapshotnum]=self.cat[snapshotnum][self.mkind][halindexnum]
#avgratio=np.average(massmap[:,snap]/massmap[:,0] for snap in self.snapshotindex)
self.avgratios=[np.average(10.**massmap[:,snap]/10.**massmap[:,0]) for snap in self.snapshotindex]
self.massmap=massmap
def mM0s_add_f_new(hosti0):
mtype = 'm.fof'
mM0s = []
M0 = hostcat[0][mtype][hosti0]
for zi in allzis[:-1]:
i_primary = indices_tree(hostcat, 0, zi, hosti0)
if i_primary < 1:
return mM0s
is_prog = hostcat[zi + 1]['chi.i'] == i_primary
is_prog[hostcat[zi]['par.i'][
i_primary]] = False #is_prog is a bool array. This line sets the elements corresponding to the main progentior to false, so we're not incorrectly counting a merger of the main progenitor with itself.
ms = hostcat[zi + 1][mtype][is_prog]
mM0s_add = ms - M0
mM0s += list(mM0s_add)
return mM0s
def mM0s_add_f(hosti0, excl=False):
mM0s = []
M0 = hostcat[0]['m.fof'][hosti0]
subis_prev = []
for zi in allzis:
#print'\n\nsnapshot %i'%zi
hosti = indices_tree(hostcat, 0, zi, hosti0)
#print'\nhost idx: %i'%hosti
if hosti < 1:
return mM0s
#The following commented block of code uses the getinfall method to count when subhalos entered host halos. It may come in handy later, so I'm not deleting it.
'''
subis=getsubs(hosti,zi)
isnew=np.array([not subi in subis_prev for subi in subis],
dtype=bool)
subis_inf,zis_inf=getinfall(subis,zi)
infhaps=subis_inf>0 #If the subhalo is part of the host for the whole simulation, the indices will be -1.
#subis_inf,zis_inf=subis_inf[infhaps],zis_inf[infhaps]
subis_b4inf,zis_b4inf=subis_inf[infhaps],zis_inf[infhaps]
zis_inf=zis_b4inf-1
subis_inf=[indices_tree(subcat,zi_b4inf,zi_inf,subi_b4inf)
for zi_b4inf,zi_inf,subi_b4inf
in zip(zis_b4inf,zis_inf,subis_b4inf)]
ms=[subcat[zi_inf][msubtype][subi_inf]
for zi_inf,subi_inf
in zip(zis_inf,subis_inf)]
mM0s_add=ms-M0
mM0s+=list(mM0s_add)
subis_prev=subis
'''
if not excl:
nhosti = hostcat[zi]['par.n.i'][hosti]
while nhosti > 0:
#print'next host idx: %i'%nhosti
m = hostcat[zi]['m.fof'][nhosti]
mM0_add = m - M0
#print mM0s[-1]
mM0s += list(mM0_add.flatten())
#print mM0s[-2:]
nhosti = hostcat[zi]['par.n.i'][nhosti]
return mM0s
def tracker_with_opt(self,zis=np.arange(35),kind='merger'):
mfrackey='m.frac.min'
thresh=0.1
his=np.arange(len(self.cat[self.snapshotindex[-1]]['halo.i']))
'''
#FOR TESTING####
n=int(1e5)
his=np.array(random.sample(his,n)) #Take a radom sample for testing
#FOR TESTING####
'''
print'starting with %i halos' %len(his)
m_M0s=[]
M0s=[]
#This next line might be redundant, because it may have been originally intended to feed the line after itself, and that line after is now commented.
iscen=self.cat[self.snapshotindex[-1]]['ilk'][his]==1 #specifying his here in the first step is usually redundant, but I'm including it to cover special case where we start with less than the full catalog of his
#mfracsprev=np.repeat(1.,sum(~iscen))
#mfracsprev=np.repeat(1.,len(his))
mfracsprev=np.zeros(len(his))
pbar=ProgressBar()
#for zi in pbar(self.snapshotindex[::-1]):
for zi in zis[::-1]:
print'\nsnapshot %i' %zi
iscen=self.cat[zi]['ilk'][his]==1
#print'%i non-centrals'%sum(~iscen)
#his_nc=his[~iscen] #Do I really want to be removing centrals here? I think so, but verify this.
mfracs=self.cat[zi][mfrackey][his]
smaller=mfracs<mfracsprev
destd=mfracs<=thresh #qualifies as destroyed
isev=smaller & ~iscen #qualifies as an event
if kind=='merger':
isev=smaller & destd & ~iscen #qualifies as an event
else:
isev=smaller & ~iscen
his_ev=his[isev]
#print'%i newly destroyed non-central halos' %len(his_ev)
mmaxs_ev=self.cat[zi]['m.max'][his_ev]
mfracs_ev=mfracs[isev]
ms_inst=(mmaxs_ev*mfracs_ev) #The program currently does not use this data
chis=self.cat[zi]['halo.i'][his_ev] #central halo indices---Don't confuse with chiis (child halo indices)
#fchis=np.array(indices_tree(self.cat,zi,0,chis)) #z=0 indices of central halos
fchis=indices_tree(self.cat,zi,0,chis) #z=0 indices of central halos
has_fchi=fchis>=0 #if indices_tree returns a negative for the final central halo index, there is no central at z=0.
fchis=fchis[has_fchi]
#print'%i final halos for %i newly destroyed halos' %(len(fchis),len(his_ev))
#M0s=self.cat[0]['m.max'][fchis]
M0s_add=self.cat[0]['m.max'][fchis]
#inmbin=(M0s<self.mhal0+self.mwidth/2.)&(M0s>self.mhal0-self.mwidth/2)
#ms=ms[has_fchi][inmbin] #Cut the ms array down to elements whose central exists at z=0. Then pull elements of that array (the shape of which matches fchis) whose centrals are in the mbin.
ms=mmaxs_ev[has_fchi].flatten() #Cut the mmaxs_ev array down to elements whose central exists at z=0. I'm not going to eliminate elements outside the mbin, because I want to only run this once, and it's probably a better idea to just record m_M0 along with what the M0 is and then narrow down the m_M0's later.
#The reason I need to flatten the array: If mmaxs_ev has only one element, the mmaxs_ev[has_fchi] array returns a nested array, apparently because it evaluates both the single element and the dtype=float32 descriptor. I have no idea why it does this, but flattening the resulting masked array is a work around.
#M0s=M0s[inmbin] #M0s was made from fchis, so we don't need to cut anything before taking inmbin mask.
m_M0s_add=ms-M0s_add
m_M0s_add=np.minimum(m_M0s_add,-m_M0s_add)
#print'new m_M0 ratios:'
#print m_M0s_add
'''
print"from m.max's:"
print ms
print"from M0's:"
print M0s_add
'''
M0s+=list(M0s_add)
m_M0s+=list(m_M0s_add)
#prep for next run:
his=his[~isev] #Remove affected subhalos from next evaluation.
mfracsprev=mfracs[~isev] #Remove mfracs for affected subhalos
#print 'removing %i destroyed halos. %i halos remaining'%(sum(destd),len(his))
chiis=self.cat[zi]['chi.i'][his] #child indices
his=chiis
self.M0s=np.array(M0s)
self.m_M0s=np.array(m_M0s)
#print''
#print m_M0s
timestmp='{:%Y%m%d}'.format(datetime.datetime.now())
#filename='./dat/true_m_M0_{0:0.0f}_{2}_{1}.h5'.format(mmid,timestmp,self.mkind)
filename='./dat/true_m_M0_{1}_{0}.h5'.format(timestmp,self.mkind)
f = h5py.File(filename, 'w')
f.create_dataset('m_M0s', data=self.m_M0s)
f.create_dataset('M0s',data=self.M0s)
f.create_dataset('N_fc',data=len(self.halis[0]))
f.close()