def RadioCuts(val, compradio=False): smt = iom.SmartTiming() smt(task='RadioAndMock_initialization') (pase, realisations, survey) = val Rmodel = survey.Rmodel snapMF, strSn, smt_add = LoadSnap_multiprocessing(pase,realisations,Rmodel, getstring=True) if compradio: (snap,subsmt) = radiomodel.CreateRadioCube(snapMF, Rmodel, realisations[0].mockobs.z_snap, nuobs=pase['nu_obs'])[0:2] smt.MergeSMT_simple(subsmt, silent=True) smt(task='UpdateHeader') realisations[0].z.value = realisations[0].mockobs.z_snap realisations[0].Mvir.value = snap.head['Mvir']*snap.head['hubble'] realisations[0].updateInformation() snap.head['M200'] = realisations[0].M200.value """ Here we compute the volume weighted radio emission """ radiosum = np.sum(snap.radi) borders = 2*realisations[0].R200*snap.head ['hubble']/snap.head ['aexpan'] whereR200 = np.where( np.sqrt(np.power(snap.pos[:,0],2) + np.power(snap.pos[:,1],2) + np.power(snap.pos[:,2],2) ) < borders/2 ) radiosum_R200 = np.sum(snap.radi[whereR200]) # update information on the total radio power (at the rest frame frequency) in the simulational volume for kk,real in enumerate(realisations): realisations[kk].P_rest.value = radiosum # This is for a frequency differing from 1.4 GHz and an efficiency of 1, in PostProcessing.py we apply a further correction realisations[kk].Prest_vol.value = radiosum_R200 # This is for a frequency differing from 1.4 GHz and an efficiency of 1, in PostProcessing.py we apply a further correction else: (snap, MF) = snapMF smt(task='Shed_DoMockObs_misc') if suut.TestPar(pase['redSnap']): # This is all part of reducing the data load. A shrinked version of the snapshot with less particles is saved in the custom format that is a fork of the gadget format redsnap = radiomodel.PiggyBagSnap_cut(snap, snap, float(pase['cutradio']), cutmask = MF ) strSn = strSn.replace('cluster.', 'clusterSUBSET.') strSn = strSn.replace(pase['snapfolder'], pase['outf']) print(strSn) redsnap.savedata(strSn) # original snapshot if compradio: print('np.sum(radiocube[0].radi)', np.sum(snap.radi), '-->', np.sum(redsnap.radi), 'i.e.', radiosum, radiosum_R200, 'pickled to', strSn) return (realisations, Rmodel), smt
def LoadSnap_multiprocessing(pase, realisations, Rmodel, getstring=False, verbose=False): smt = iom.SmartTiming() smt(task='LoadSnaps') gcl = realisations[0] """ We load the radio cubes """ strSn = (pase['snapfolder'] + 'SHOCKS_%05i/cluster.%05i.snap.%03i.shocks') % (gcl.mockobs.clid, gcl.mockobs.clid, gcl.mockobs.snap) # if suut.TestPar(pase['useMiniCube']): # subset of snapshot, pickled # strSn = strSn.replace('cluster.', 'clusterSUBSET.') # if verbose: print('Loading snapshot:',strSn) # print('___ RunSurvey::LoadSnap_multiprocessing::',strSn,pase['useMiniCube'],suut.TestPar(pase['useMiniCube'])) # snap = iom.unpickleObject(strSn) # try: # snap = iom.unpickleObject(strSn) # except: # with open('/data/ErrorLog.txt',"a") as f: # for gcl in realisations: # f.write(strSn+'\n') # # else: # original snapshot # if verbose: print('Loading snapshot:',strSn) # snap = loadsnap.Loadsnap(strSn,headerc=pase['headerC']) # original snapshot if suut.TestPar(pase['useMiniCube']): # asks: original or modified snapshot? strSn = strSn.replace('cluster.', 'clusterSUBSET.') if verbose: print('Loading snapshot:',strSn) snap = loadsnap.Loadsnap(strSn,headerc=pase['headerC']) """psi and machfiles could become sharred (or global) arrays, but as they are quite small < 1MB, the impact on performance should be snmall""" PreSnap = radiomodel.PrepareRadioCube(snap, psiFile=pase['miscdata']+pase['PSItable'], machFile=pase['miscdata']+pase['DSAtable']) PreSnap = ( radiomodel.PiggyBagSnap(PreSnap[0]), PreSnap[1] ) if getstring: return PreSnap, strSn, smt else: return PreSnap, smt
def DoRun(inputs, smt, verbose=False, countmax=500, countmax_relics=1500): """ Please mind that this procedure determines early if the number of detected relics becomes to large!""" (pase, survey) = inputs count = 0 count_relics = 0 realisations = [] realisations_list = [] # rotated realisations of one and the same cluster survey.GCls = sorted(survey.GCls, key= iom.Object_natural_keys) # This checks if the snapshot has to be loaded ... I would use a pool of loaded, snapshots ... but this is cumbersome # Each snapshot is loaded only once ... If the number of models&rotations to be tested is high enough the produced overhead is low # This requires that the clusters are ordered due to cluster number and snapshot for gcl in survey.GCls: if (len(realisations) == 0 or gcl.mockobs.clid != realisations[0].mockobs.clid or gcl.mockobs.snap != realisations[0].mockobs.snap): if len(realisations) > 0: realisations_list.append(realisations) realisations = [gcl] else: realisations.append(gcl) realisations_list.append(realisations) for realisations in realisations_list: gcl = realisations[0] if verbose: print('Recognized ID %5i, snap %3i, #%i in cluster file' % (gcl.mockobs.clid, gcl.mockobs.snap, gcl.mockobs.id) ) smt(task='LoadSnaps') """ We load the radio cubes """ strSn = (pase['snapfolder'] + 'SHOCKS_%05i/cluster.%05i.snap.%03i.shocks') % (gcl.mockobs.clid, gcl.mockobs.clid, gcl.mockobs.snap) """ SMELLY: This causes some issues, as there are two different 'load' versions for one and the same task """ if suut.TestPar(pase['useMiniCube']): # original snapshot strSn = strSn.replace('cluster.', 'clusterSUBSET.') if verbose: print('Loading snapshot:', strSn) snap = loadsnap.Loadsnap(strSn, headerc=pase['headerC']) smt(task='PrepareRadioCubes') PreSnap = radiomodel.PrepareRadioCube(snap, psiFile=pase['miscdata']+pase['PSItable'], machFile=pase['miscdata']+pase['DSAtable']) if 1==2: snap_phd = radiomodel.PrepareRadioCube(snap, psiFile=pase['miscdata'] + pase['PSItable'], machFile=pase['miscdata'] + pase['DSAtable'], machmin=0.0)[0] print(type(snap_phd.mach)) Mstat = np.asarray(snap_phd.mach)/1.045+1e-5 Astat = np.asarray(snap_phd.hsml)/np.asarray(loadsnap.comH_to_phys(snap_phd.head))**2 Rhostat = np.asarray(snap.rdow) Tstat = np.asarray(snap.udow) Psistat = np.asarray(snap.DSAPsi) bins = np.linspace(-1, 3, num=1300, endpoint=True) print(Mstat.shape, Tstat.shape, Psistat.shape) M_hist, bin_edges = np.histogram(np.log10(Mstat), bins=bins) A_hist, bin_edges = np.histogram(np.log10(Mstat), weights=Astat, bins=bins) Rho_hist, bin_edges = np.histogram(np.log10(Mstat), weights=Rhostat, bins=bins) T_hist, bin_edges = np.histogram(np.log10(Mstat), weights=Tstat, bins=bins) Psi_hist, bin_edges = np.histogram(np.log10(Mstat), weights=Psistat, bins=bins) Psi_A_hist, bin_edges = np.histogram(np.log10(Mstat), weights=Psistat*Astat, bins=bins) Psi_A_T_hist, bin_edges = np.histogram(np.log10(Mstat), weights=Psistat*Astat*Tstat**(1.5), bins=bins) Psi_A_T_Rho_hist, bin_edges = np.histogram(np.log10(Mstat), weights=Psistat*Rhostat*Astat*Tstat**(1.5), bins=bins) Psi_A_Rho_hist, bin_edges = np.histogram(np.log10(Mstat), weights=Rhostat*Astat, bins=bins) alltogether = np.stack((M_hist, A_hist, Rho_hist, T_hist, Psi_hist, Psi_A_hist, Psi_A_T_hist, Psi_A_T_Rho_hist,Psi_A_Rho_hist), axis=1) print( len(snap.mach), alltogether.shape) for fr in realisations: np.save("/data/TestForPhD/TestForPhD-%i" % (fr.ids), alltogether) PreSnap = (radiomodel.PiggyBagSnap(PreSnap[0], extended=True), PreSnap[1]) if verbose: print(' ___ Particles in snap ___ :', PreSnap[0].radi.shape) # DEBUGGING """ now we'll assign functions to the pool """ inargs = (PreSnap, pase, realisations, survey) #(radiocube, B0, kappa, z, strSn, interpolate) # , int(TestPar(pase['default'])) stage1_outSmall, smt_small = RadioAndMock_loaded(inargs, verbose=verbose) smt.MergeSMT_simple(smt_small) mupro_Output_NicePickleClusters([stage1_outSmall], survey.outfolder) """ pickles a bunch of single galaxy clusters, they are latter joined into a survey """ """ It should also pickle the corresponding fits images (in case of a detection) """ """ Block BEGIN: If you choose a poor model then you might end up with way more relic clusters then expected. I presume that those both slows down the process and leads to working memory issues. To prevent this I stop the computation if the weighted relic count is way higher than the expected relic count. In this case I should let the procedure stop early and give it the minimum score in the metric ...(also in the metric test) """ for gcl_test in stage1_outSmall[0]: # print(survey.outfolder, gcl_test.stoch_drop(survey.seed_dropout)) count_relics_now = len(gcl_test.filterRelics(**survey.relic_filter_kwargs)) if count_relics_now > 0: count += 1 count_relics += count_relics_now #print(count, count_relics) if count > countmax or count_relics > countmax_relics: print('Because the number of relics already now is larger than %i the function DoRun() is terminated.' % countmax_relics) return False, smt """ Block END """ realisations = [] # Clear rotations of clusters, so that append, can work for a new try, ... # formerly: del realisations if verbose: print("#=== Proccesses completed. Please check for the data output.'") if verbose: smt(forced=True) return False, smt
def main(parfile, workdir=None, ABC=None, verbose=False, survey=None, index=None, Clfile='clusterCSV/MUSIC2-AGN', processTasks=True): """ input: parameter file: ABC : None or a list of parameters (what a pity that a dictionary is not possible with the current abcpmc or ABCpmc module) output: some strings to track down the output directories once a survey is not None all the default survey values will be used; i.e. the parfile will be considered much For future: - delete survey findings (or add for different detection parameter) or make the Rmodel changeable If pase['default'] is False then a run will be made with one shell and one single cluster realisation per snapshot For abcpmc MUSIC-2 vanilla use MUSIC2-AGN for clusterCSV and MUSIC2_NVSS02_SSD.parset for parset MUSIC-2cooling use MUSIC2-AGN for clusterCSV and MUSIC2COOL_NVSS.parset for parset """ RModelID = os.getpid() # get process id seed = random.randrange(4294967295) np.random.seed(seed=seed) """also possible : np.random.seed(seed=None) ... this here is only to save the seed, which is not needed, because all the random stuff can be reconstructed from the cluster statistics processes from random are well seeded even without this, somehow numpy needs this kind of seed but only in abcpmc and not ABC import random random.randrange(sys.maxsize) """ # === Read parset; then extract fundamental parameters ... Parset OBLIGATORY has be saved as 'parsets/*.parset' if workdir is None: workdir = os.path.dirname(__file__) + '/' pase, Z = suut.interpret_parset(parfile, repository=workdir + '/parsets/') # TODO: workdir should be the same as pase['miscdir'] yet the issue is that it is unknown before miscdir is known. if survey is None: surveyN = parfile.replace('.parset', '') savefolder = pase['outf'] + surveyN logfolder = pase['outf'] + surveyN else: surveyN = survey.name savefolder = survey.outfolder logfolder = survey.logfolder # Constants # ==== Cosmological Parameter - MUSIC-2 Omega_M = 0.27 # Matter density parameter # === Create folder if needed iom.check_mkdir(savefolder) iom.check_mkdir(logfolder) smt = iom.SmartTiming(rate=pase['smarttime_sub'], logf=savefolder + '/smt'); smt(task='Prepare_Clusters') # === Create detection information dinfo = cbclass.DetInfo(beam=[float(pase['S_beam']), float(pase['S_beam']), 0], spixel=float(pase['S_pixel']), rms=float(pase['RMSnoise']) * 1e-6, limit=float(pase['RMSnoise']) * float(pase['Detthresh']) * 1e-6, nucen=float(pase['nu_obs']), center=(0, 0), survey='UVcoverage') if survey is None: """Create all galaxy clusters: All these steps are to decide which clusters to use. Better placement: in SurveyUtils""" """ Read the cluster lists from MUSIC-2 for all snapshots """ all_clusters = pd.read_csv('%s%s_allclusters.csv' % (pase['miscdata'], Clfile)) if verbose: all_clusters.info() zsnap_list = pd.Series(all_clusters['redshift'].unique()) snapidlist = pd.Series(all_clusters['snapID'].unique()) clusterIDs = list(all_clusters['clID'].unique()) NclusterIDs = [len(all_clusters[all_clusters['redshift'] == z]) for z in zsnap_list] misslist = np.loadtxt(pase['miscdata'] + pase['missFile']) """ e.g. cluster 10# was not (re)simulated, in neither of the MUSIC-2 simulations (also 7 has some issues?)""" GClList = [] if pase['snaplistz'] != 'None': snaplistz = [float(z) for z in iom.str2list(pase['snaplistz'])] snapidlist = [float(z) for z in iom.str2list(pase['snapidlist'].replace(' ', ''))] zsnap_list = (snaplistz[::-1])[0:11] # 0:17 List of available sn [0:11] snapidlist = (snapidlist[::-1])[0:11] # 0:17 [0:11] NclusterIDs = [len(all_clusters['clID'].unique().tolist())] * len(snaplistz) if verbose: print('NclusterIDs', NclusterIDs[0]) use_list = [True] * len(zsnap_list) # Also put some False, you don't really want to use the z=4.0 snapshots! Vsimu = (1.0 / (myu.H0 / 100.)) ** 3 # Gpc**3 comoving volume """ Iterate trough each shell of your z-onion and attribute clusters to them with z-range and percentage of covered sky, we have z=0.1 """ if not suut.TestPar(pase['default']): N_shells = 1 else: N_shells = float(pase['N_shells']) shells_z, delta_z = np.linspace(Z[0], Z[1], num=N_shells + 1, retstep=True) cosmo = FlatLambdaCDM(H0=myu.H0, Om0=Omega_M) DCMRs = cosmo.comoving_volume(shells_z).value / 1e9 count = 0 for (zlow, zhigh, VCMlow, VCMhigh) in zip(shells_z[0:-1], shells_z[1:], DCMRs[0:-1], DCMRs[1:]): """ Iterate through each shell of the observed volume and assign clusters """ boundaries_z = (zlow, zhigh) VCM = (VCMlow, VCMhigh) z_central = np.mean(boundaries_z) if not suut.TestPar(pase['default']): z_central = 0.051 choosen = suut.assign_snaps(zsnap_list, boundaries_z, VCM[1] - VCM[0], NclusterIDs, sigma_z=float(pase['sigma_z']), skycoverage=float(pase['surv_compl']), Vsimu=Vsimu, use_list=use_list, fake=(not suut.TestPar(pase['default'])), logmode=None) for (snap, kk) in choosen: l = all_clusters[(all_clusters["clID"] == clusterIDs[kk]) & (all_clusters["snapID"] == snapidlist[snap])] """ It would be good if you could directly access the element like in an ordered list, as this would dramatically speed up the process """ """ Skips missing snapshots --> they will also miss in the .csv""" if len(l) == 0: if verbose: print('__ Missing snapshot:', clusterIDs[kk], snapidlist[snap]) continue ids = int(l["clID"]) M200 = float(l["M200"]) # Filter for the cluster masses. Please mind that this filtering step is also redshift dependent if suut.TestPar(pase['empicut']) and np.log10(M200) < (13.6 + 2 * z_central): continue count += 1 # Decide on the projection of the cluster # it would be great if a random initializer between 0 and 1 could have been saved, if suut.TestPar(pase['rotation']): theta = np.arccos(uniform(0, 2) - 1) phi = uniform(0, 2 * np.pi) psi = uniform(0, 2 * np.pi) else: theta = 0 phi = 0 psi = 0 # Create mockObs and the galaxyCluster_simulation mockObs = cbclass.MockObs(count, theta=theta, phi=phi, psi=psi, snap=snapidlist[snap], z_snap=zsnap_list[snap], clid=ids, snapfolder=pase['xrayfolder'], xrayfolder=pase['xrayfolder'], headerc=pase['headerC']) GClList.append( cbclass.Galaxycluster_simulation("MUSIC2%05i-%06i-%06i" % (ids, snapidlist[snap], count), count, z=z_central, M200=M200, dinfo=dinfo, mockobs=mockObs)) # , **addargs # Also create a list of the chosen clusters for later loockup GClList = sorted(GClList, key=lambda x: (x.mockobs.clid, -x.mockobs.snap)) if verbose: print('Length of GClList:', len(GClList)) """ New approach: Create a list of modes for the radio emission (Rmodels) """ surmodel = None if ABC is None: """CAVEAT: The issue with the currently used ABC routines is that you have to give them arrays. Which is why the corresponding model associated has to be defined at this layer. Giving the procedure a function which would create this array would allow all of this to be defined in the top layer of ABC """ RModel = cbclass.RModel(RModelID, effList=[float(pase['eff'])], B0=float(pase['B0']), kappa=float(pase['kappa']), compress=float(pase['compress'])) if suut.TestPar(pase['redSnap']): RModel.effList = RModel.effList[0] elif len(ABC) == 1: """ Vary only efficiency """ (lgeff) = ABC RModel = cbclass.RModel(RModelID, effList=[10 ** lgeff], B0=1, kappa=0.5, compress=float(pase['compress'])) elif len(ABC) == 2: """ Vary efficiency and B0""" (lgeff, lgB0) = ABC RModel = cbclass.RModel(RModelID, effList=[10 ** lgeff], B0=10 ** lgB0, kappa=0.5, compress=float(pase['compress'])) print('#== Begin Processing task') elif len(ABC) == 3: """ Varies the standard model """ (lgeff, lgB0, kappa) = ABC RModel = cbclass.RModel(RModelID, effList=[10 ** lgeff], B0=10 ** lgB0, kappa=kappa, compress=float(pase['compress'])) elif len(ABC) == 4: """ Varies the standard model + detection probability """ (lgeff, lgB0, kappa, survey_filter_pca_b) = ABC RModel = cbclass.RModel(RModelID, effList=[10 ** lgeff], B0=10 ** lgB0, kappa=kappa, compress=float(pase['compress'])) surmodel = cbclass.SurModel(b=survey_filter_pca_b) elif len(ABC) == 6: (lgeff, lgB0, kappa, lgt0, lgt1, lgratio) = ABC RModel = cbclass.PreModel_Hoeft(RModelID, effList=[10 ** lgeff], B0=10 ** lgB0, kappa=kappa, compress=float(pase['compress']), t0=10**lgt0, t1=10**lgt1, ratio=10**lgratio) Rm = RModel elif len(ABC) == 7: (lgeff, lgB0, kappa, survey_filter_pca_b, lgratio, lgt0, lgt1) = ABC RModel = cbclass.PreModel_Hoeft(RModelID, effList=[10 ** lgeff], B0=10 ** lgB0, kappa=kappa, compress=float(pase['compress']), t0=10 ** lgt0, t1=10 ** lgt1, ratio=10 ** lgratio) Rm = RModel surmodel = cbclass.SurModel(b=survey_filter_pca_b) else: print('RunSurvey::main: model unknown') return """ Create survey """ outfolder = '%s_%05i/' % (logfolder, RModelID) survey = cbclass.Survey(GClList, survey='%s' % (parfile.replace('.parset', '')), emi_max=float(pase['RMSnoise']) * 1e-3 * 200, cnt_levels=[float(pase['RMSnoise']) * 2 ** i for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], saveFITS=(ABC is None), savewodetect=suut.TestPar(pase['savewodetect']), dinfo=dinfo, surshort='MUSIC2', Rmodel=RModel, outfolder=outfolder, logfolder=logfolder) survey.set_surmodel(surmodel) survey.set_seed_dropout() else: """ If you directly loaded a survey, just use its internal Rmodel """ RModel = survey.Rmodel if verbose: print('Outfolder:', survey.outfolder) """=== Create a Task Cube, modify it & save it The function of this Taskcube formerly was to keep track of all the computations that were already done in my multiproccecing version of ClusterBuster Now it is outdated and isn't maintained anymore. After a BUG I didn't want to fix I decommisened this functionality """ Taskcube = np.zeros((len(survey.GCls), len([RModel]))) # A cube of all possible entries , efficiency is always fully computed and thus not in the Taskcube if suut.TestPar(pase['reCube']): Taskcube = np.load(logfolder + '/TaskCube.npy') smt.MergeSMT_simple(iom.unpickleObject(logfolder + '/smt')) if int(pase['reCL']) + int(pase['reRM']) > 0: for (GCl_ii, RModelID), status in np.ndenumerate(Taskcube[:, :]): if verbose: print('GCl_ii, RModelID:', GCl_ii, RModelID) if GClList[GCl_ii].mockobs.clid > int(pase['reCL']) and int(pase['reRM']): break else: Taskcube[GCl_ii, RModelID] = 1 np.save(logfolder + '/TaskCube', Taskcube) # also to be pickled/saved: Levels Cluster&TaskID --> B0, kappa, (z) --> eff0 """""" if verbose: print('#== Begin Processing task') """ This is the most important task! """ while processTasks: processTasks, smt = DoRun((pase, survey), smt, verbose=verbose) print('RModelID %i of run %s finished' % (RModelID, surveyN)) return survey
def RadioAndMock(val, verbose=True): smt = iom.SmartTiming() smt(task='RadioAndMock_initialization') (pase, realisations, survey) = val Rmodel = survey.Rmodel PreSnap, smt_add = LoadSnap_multiprocessing(pase, realisations, Rmodel) if len(PreSnap) > 0: snapMF = PreSnap (radiosnap, subsmt) = radiomodel.CreateRadioCube(snapMF, Rmodel, realisations[0].mockobs.z_snap, nuobs=pase['nu_obs'])[0:2] smt.MergeSMT_simple(subsmt, silent=True) """ This weird interresult comes from output.put( outp + (Rmodel,)) #Rmodel is added to the tuple (radiocube, subsmt, Rmodel) = stage1_out.get() stage1_list.append( ( radiocube, Rmodel, survey) ) """ radiocube = (radiosnap, Rmodel, survey) #Rmodel is added to the tuple ##=== Stage II - DoMockObs if verbose: print('Start compiling MockObservations for further models of cluster #%5i and snap #%3i with in total %i realisations.' % (realisations[0].mockobs.clid , realisations[0].mockobs.snap, len(realisations))) smt(task='Shed_DoMockObs') # This result of this computation is independent of rotation and because of this was put here for kk, real in enumerate(realisations): # update information on the total radio power (at the rest frame frequency) in the simulational volume """ This is wrong and has to be fixed in the future!!!! """ """ also possible: realisations[kk].Rvir = radiocube[0].head['Rvir']""" if realisations[kk].M200.value == 0: try: realisations[kk].M200.value = radiocube[0].head['M200'] except: realisations[kk].Mvir.value = radiocube[0].head['Mvir'] realisations[kk].updateInformation(massproxis=True) """ Here we compute the volume weighted radio emission """ radiosum = np.sum(radiocube[0].radi) borders = 2*realisations[0].R200*radiocube[0].head ['hubble']/radiocube[0].head ['aexpan'] whereR200 = np.where( np.sqrt(np.power(radiocube[0].pos[:,0],2) + np.power(radiocube[0].pos[:,1],2) + np.power(radiocube[0].pos[:,2],2) ) < borders/2 ) radiosum_R200 = np.sum(radiocube[0].radi[whereR200]) # update information on the total radio power (at the rest frame frequency) in the simulational volume for kk,real in enumerate(realisations): realisations[kk].P_rest.value = radiosum # This is for a frequency differing from 1.4 GHz and an efficiency of 1, in PostProcessing.py we apply a further correction realisations[kk].Prest_vol.value = radiosum_R200 # This is for a frequency differing from 1.4 GHz and an efficiency of 1, in PostProcessing.py we apply a further correction smt(task='Shed_DoMockObs_misc') locations = [survey.outfolder] if not suut.TestPar(pase['cutradio']): radiocubeUse = radiocube else: print('Beware, This is slow and should not be paralised!!!! This part is not implemented') radiocubeUse = None #radiomodel.PiggyBagSnap_cut(snap, radiocube[0], float(pase['cutradio'])),Rmodel,survey)] (nouse, subsmt, GClrealisations_used, Rmodel) = mockobs.Run_MockObs(radiocubeUse, realisations, saveFITS=survey.saveFITS, savewodetect=survey.savewodetect, writeClusters=True) #Mach=pase['Mach'], Dens=pase['Dens'], smt.MergeSMT_simple(subsmt, silent=True) return (GClrealisations_used, Rmodel), smt
def RadioAndMock_loaded(val, verbose=True): smt = iom.SmartTiming() smt(task='RadioAndMock_initialization') (snapMF, pase, realisations, survey) = val Rmodel = survey.Rmodel ##=== Stage II - DoMockObs if verbose: print('Start compiling MockObservations for further models of cluster #%5i snap #%3i with in total %i realisations.' % (realisations[0].mockobs.clid, realisations[0].mockobs.snap, len(realisations))) GClrealisations_return = [] smt(task='Shed_DoMockObs_misc') # This result of this computation is independent of rotation and because of this was put here for kk, realisation in enumerate(realisations): # update information on the total radio power (at the rest frame frequency) in the simulational volume """ This is wrong and has to be fixed in the future!!!! Currently, we make this code really SMELLY and hard to understand """ (radiosnap, subsmt, poisson_factor) = radiomodel.CreateRadioCube(snapMF, Rmodel, realisation.mockobs.z_snap, nuobs=pase['nu_obs'], logging=False)[0:3] smt.MergeSMT_simple(subsmt, silent=True) """ also possible: realisations[kk].Rvir = radiocube[0].head['Rvir']""" if realisations[kk].M200.value == 0: try: realisations[kk].M200.value = radiosnap.head['M200'] except: realisations[kk].Mvir.value = radiosnap.head['Mvir'] realisations[kk].updateInformation(massproxis=True) """ Here we add the radio emission due to pre-existing electrons """ if isinstance(Rmodel, cbclass.PreModel_Gelszinnis): randfactor = 10**np.random.normal(0, Rmodel.p_sigma, 1) realisation.PreNorm = randfactor*Rmodel.p0 radiosnap.radiPre += realisations.PreNorm * radiosnap.radiPre elif isinstance(Rmodel, cbclass.PreModel_Hoeft): realisation.poisson_factor = poisson_factor """ Here we compute the volume weighted radio emission """ radiosum = np.sum(radiosnap.radi) borders = 2*realisations[0].R200*radiosnap.head ['hubble']/radiosnap.head ['aexpan'] whereR200 = np.where(np.sqrt(np.power(radiosnap.pos[:,0], 2) + np.power(radiosnap.pos[:,1], 2) + np.power(radiosnap.pos[:,2], 2)) < borders/2) radiosum_R200 = np.sum(radiosnap.radi[whereR200]) # update information on the total radio power (at the rest frame frequency) in the simulational volume realisations[kk].P_rest.value = radiosum # This is for a frequency differing from 1.4 GHz and an efficiency of 1, in PostProcessing.py we apply a further correction realisations[kk].Prest_vol.value = radiosum_R200 # This is for a frequency differing from 1.4 GHz and an efficiency of 1, in PostProcessing.py we apply a further correction if not suut.TestPar(pase['cutradio']): radiosnapUse = copy.deepcopy(radiosnap) if hasattr(radiosnapUse, 'radiPre'): radiosnapUse.radi += radiosnapUse.radiPre #print('Run_MockObs:: Ratio of PREs to total emission', (np.sum(radiosnapUse.radiPre)) / (np.sum(radiosnapUse.radi) + np.sum(radiosnapUse.radiPre))) radiocube = (radiosnapUse, Rmodel, survey) # Rmodel is added to the tuple else: print('Beware, This is slow and should not be paralised!!!! This part is not implemented') radiocube = (radiosnap, Rmodel, survey) # Rmodel is added to the tuple smt(task='Shed_DoMockObs') (nouse, subsmt, GClrealisation_used, Rmodel) = mockobs.Run_MockObs(radiocube, [realisation], saveFITS=survey.saveFITS, savewodetect=survey.savewodetect, side_effects=True) GClrealisations_return += GClrealisation_used smt.MergeSMT_simple(subsmt, silent=True) return (GClrealisations_return, Rmodel), smt