Develop

Contributions to Salmo development are welcome. So far this page is just composed of some simple descriptions of source codes. More contents will be added when they are urged.

List of files

• main.c/.h
• sampling.c/.h
• parameters.c/.h
• commonHeader.c/.h
• FITSFunctions.c/.h
• HEALPixFunctions.c/.h

main

This is where the menu and the instructions live.

sampling

This is where different processing functions live.

Structures

This structure stocks a "type map":

typedef struct type_map;

This is an array of HEALPix maps:

typedef struct HPMap_arr;

These are for stocking galaxy catalogues:

typedef struct gal_t;
typedef struct gal_node;
typedef struct gal_list;
typedef struct gal_list_mat;

Functions related to initialization

type_map *initialize_type_map(long long nsidePix);
void free_type_map(type_map *tMap);
void reset_type_map(type_map *tMap);
gal_node *initialize_gal_node();
gal_list *initialize_gal_list();
void free_gal_list(gal_list *gList);
gal_list_mat *initialize_gal_list_mat(int N_z_map, int nbTypes);
void free_gal_list_mat(gal_list_mat *gListMat);

Functions related to sampling

There are 2 ways to stock masking information in Salmo: "type map" and "ratio map". These are setup functions:

void setTypeMap(Salmo_param *sPar, type_map *tMap, HPMap_t *mask);
void setRatioMaps(Salmo_param *sPar, HPMap_arr *rMapArr);

The following is for loading and setting up redshift distributions:

void readAsciiNOfZ(char name[], interpolator_t *inter, int verbose);
void setNOfZArr(Salmo_param *sPar, interpolator_t *inter, sampler_arr *nOfZArr);

The following is for variable depth. We set up depth maps and variable depth n(z) with the following:

void setDepthMaps(Salmo_param *sPar, HPMap_arr *vdMapArr);
void setVDNOfZArr(Salmo_param *sPar, interpolator_t *inter, sampler_arr *VD_nOfZArr);

This function stocks the information of a galaxy into a gal_t structure:

void set_gal_t(gal_t *g, double RA, double DEC, double z, double p, long long pix, double sigma_eps);

This function appends a new galaxy to a list. set_gal_t is called inside this one:

void append_gal_list(gal_list *gList, double RA, double DEC, double z, double p, 
                     long long pix, double sigma_eps);

This function deals with position sampling. It calls patchSampling3 from HEALPixFunctions.c to assign a galaxy position:

void samplePos(gsl_rng *generator, long long nside, long long pix, int N_max, int N, 
               long long *lenArr, long long *cumLenArr, long long v1, long long v2, 
               double *RAArr, double *DECArr, 
	       double z1, double z2, gal_list *gList, double sigma_eps);

Ignore this one. I have deactivated it:

void samplePos_projCL(gsl_rng *generator, long long nside, long long pix, int N_max, int N, 
                      long long *lenArr, long long *cumLenArr, long long v1, long long v2, 
                      double *RAArr, double *DECArr, 
		      sampler_t *nOfZ, gal_list *gList, double sigma_eps);

This is one of the most important functions in Salmo. This is where sampling really happens. It decides how many galaxies to generate given the expected mean, which depends on underlying matter density and redshift distributions. The process is done pixel by pixel. It has two parts. One regular part and one variable depth part:

void sampleGalaxies(Salmo_param *sPar, type_map *tMap, HPMap_arr *rMapArr, sampler_arr *nOfZArr, 
                    HPMap_arr *vdMapArr, sampler_arr *VD_nOfZArr, gal_list_mat *gListMat, 
                    HPMap_t *delta, int N_max);

Ignore these ones:

void smoothDeltaMap(Salmo_param *sPar, HPMap_t *delta, int resol);
void sampleGalaxies_projCL(Salmo_param *sPar, type_map *tMap, HPMap_arr *rMapArr, sampler_arr *nOfZArr, 
                           HPMap_arr *vdMapArr, sampler_arr *VD_nOfZArr, gal_list_mat *gListMat, 
			   HPMap_t *delta, int N_max, int resol, int nbSplits);

Functions related to lensing

These are functions which handle lensing information:

void readLensingMaps(char name[], HPMap_t *kappa, HPMap_t *gamma_1, HPMap_t *gamma_2, int verbose);
double interpolateBetweenPixels(HPMap_t *full, long long neighbor[4], double weight[4]);
void interpolateLensing(Salmo_param *sPar, gal_list_mat *gListMat, HPMap_t *k_lower, HPMap_t *g1_lower, HPMap_t *g2_lower, 
                        HPMap_t *k_upper, HPMap_t *g1_upper, HPMap_t *g2_upper);
void assignLensing(Salmo_param *sPar, gal_list_mat *gListMat, HPMap_t *kappa, HPMap_t *gamma_1, HPMap_t *gamma_2);

This is deactivated:

void assignLensing_projCL(Salmo_param *sPar, gal_list_mat *gListMat, HPMap_t *kappa, 
                          HPMap_t *gamma_1, HPMap_t *gamma_2, int nbSplits);

These functions manipulate lensing signals after they have been assigned to galaxies:

void makeG(Salmo_param *sPar, gal_list_mat *gListMat);
void addNoise(Salmo_param *sPar, gal_list_mat *gListMat);
void flipSign(Salmo_param *sPar, gal_list_mat *gListMat);

Functions related to outputs

void outFits_gal_t(FITS_t *fits, gal_t *g, double factor, int doNoise, int doWgt);
void outFitsParam(FITS_t *fits, Salmo_param *sPar, int k2);
void outFitsGalListMat(Salmo_param *sPar, gal_list_mat *gListMat, int verbose);

Functions related to lensing maps

These are deactivated:

double E_sq_of_z(double z, double Omega_m);
void fillWInterpolator(interpolator_t *w_inter, double dz, double Omega_m);
double comovDist(interpolator_t *w_inter, double z);
void makeKappaMap(Salmo_param *sPar, HPMap_t *delta, HPMap_t *kappa, interpolator_t *w_inter, 
                  double Omega_m, int zInd);
void kappaToGamma(Salmo_param *sPar, HPMap_t *kappa, HPMap_t *gamma1, HPMap_t *gamma2, 
                  double_mat *kAlm, double_mat *gAlm, double_arr *weight, int l_maxx);
void flipSignForFlask(HPMap_t *gamma1, HPMap_t *gamma2);
void outFitsLensingMaps(Salmo_param *sPar, HPMap_t *kappa, HPMap_t *gamma1, HPMap_t *gamma2, int zInd, int verbose);

Main function

Deactivated:

void processLensingMaps(Salmo_param *sPar);

These are the functions that are called in main.c for TASK equals to 2, 3, or 4:

void processMock_typeMap_LOS(Salmo_param *sPar);
void processMock_ratioMap_LOS(Salmo_param *sPar);
void processMock_ratioMap_CL(Salmo_param *sPar);
void processMock_depthMap_LOS(Salmo_param *sPar);

Deactivated:

void processMock_ratioMap_projCL(Salmo_param *sPar, int resol, int nbSplits);

parameters

Here we load and precompute parameters.

commonHeader

This is where I put some handy tools for general purposes.

FITSFunctions

This is a personalized wrapper for FITS I/O.

HEALPixFunctions

This is a personalized wrapper for HEALPix calculations.