timebinmgr.c File Reference

#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "timebinmgr.h"
#include "utils.h"

Include dependency graph for timebinmgr.c:

Go to the source code of this file.

Classes
struct	sync_params

Functions
int	cmp_double (const void *a, const void *b)
int	OutputListAction (ParameterSet *ps, const char *name, void *data)
void	set_sync_params (int OutputListLength, double *OutputListTimes)
void	setup_sync_points (double TimeIC, double TimeMax, double no_snapshot_until_time, int SnapshotWithFOF)
SyncPoint *	find_next_sync_point (inttime_t ti)
SyncPoint *	find_current_sync_point (inttime_t ti)
static double	Dloga_interval_ti (inttime_t ti)
double	loga_from_ti (inttime_t ti)
inttime_t	ti_from_loga (double loga)
double	dloga_from_dti (inttime_t dti, const inttime_t Ti_Current)
inttime_t	dti_from_dloga (double loga, const inttime_t Ti_Current)
double	get_dloga_for_bin (int timebin, const inttime_t Ti_Current)
inttime_t	round_down_power_of_two (inttime_t dti)

Variables
static SyncPoint *	SyncPoints
static int	NSyncPoints
static struct sync_params	Sync

Function Documentation

cmp_double()

int cmp_double	(	const void *	a,
		const void *	b
	)

Definition at line 17 of file timebinmgr.c.

{
    return ( *(double*)a - *(double*)b );
}

Referenced by setup_sync_points().

Here is the caller graph for this function:

dloga_from_dti()

double dloga_from_dti	(	inttime_t	dti,
		const inttime_t	Ti_Current
	)

Definition at line 256 of file timebinmgr.c.

{
    double Dloga = Dloga_interval_ti(Ti_Current);
    int sign = 1;
    if(dti < 0) {
        dti = -dti;
        sign = -1;
    }
    if((unsigned int) dti > TIMEBASE) {
        endrun(1, "Requesting dti %d larger than TIMEBASE %u\n", sign*dti, TIMEBASE);
    }
    return Dloga * dti * sign;
}

References Dloga_interval_ti(), endrun(), and TIMEBASE.

Referenced by apply_half_kick(), density(), density_ngbiter(), find_timesteps(), and hydro_ngbiter().

Here is the call graph for this function:

Here is the caller graph for this function:

Dloga_interval_ti()

static double Dloga_interval_ti ( inttime_t  ti )

static

Definition at line 207 of file timebinmgr.c.

{
    /* FIXME: This uses the bit tricks because it has to be fast
     * -- till we clean up the calls to loga_from_ti; then we can avoid bit tricks. */
 
    inttime_t lastsnap = ti >> TIMEBINS;
 
    if(lastsnap >= NSyncPoints - 1) {
        /* stop advancing loga after the last sync point. */
        return 0;
    }
    double lastoutput = SyncPoints[lastsnap].loga;
    return (SyncPoints[lastsnap+1].loga - lastoutput)/TIMEBASE;
}

References SyncPoint::loga, NSyncPoints, SyncPoints, TIMEBASE, and TIMEBINS.

Referenced by dloga_from_dti(), get_dloga_for_bin(), and loga_from_ti().

Here is the caller graph for this function:

dti_from_dloga()

inttime_t dti_from_dloga	(	double	loga,
		const inttime_t	Ti_Current
	)

Definition at line 271 of file timebinmgr.c.

{
    inttime_t ti = ti_from_loga(loga_from_ti(Ti_Current));
    inttime_t tip = ti_from_loga(loga+loga_from_ti(Ti_Current));
    return tip - ti;
}

References loga_from_ti(), and ti_from_loga().

Referenced by get_PM_timestep_ti(), and get_timestep_ti().

Here is the call graph for this function:

Here is the caller graph for this function:

find_current_sync_point()

SyncPoint* find_current_sync_point

(

inttime_t

ti

)

Definition at line 188 of file timebinmgr.c.

{
    int i;
    for(i = 0; i < NSyncPoints; i ++) {
        if(SyncPoints[i].ti == ti) {
            return &SyncPoints[i];
        }
    }
    return NULL;
}

References NSyncPoints, and SyncPoints.

Referenced by run(), test_conversions(), and test_skip_first().

Here is the caller graph for this function:

find_next_sync_point()

SyncPoint* find_next_sync_point

(

inttime_t

ti

)

this function returns the next output time that is in the future of ti_curr; if none is find it return NULL, indication the run shall terminate.

Definition at line 174 of file timebinmgr.c.

{
    int i;
    for(i = 0; i < NSyncPoints; i ++) {
        if(SyncPoints[i].ti > ti) {
            return &SyncPoints[i];
        }
    }
    return NULL;
}

References NSyncPoints, and SyncPoints.

Referenced by get_PM_timestep_ti(), run(), and test_conversions().

Here is the caller graph for this function:

get_dloga_for_bin()

double get_dloga_for_bin	(	int	timebin,
		const inttime_t	Ti_Current
	)

Definition at line 279 of file timebinmgr.c.

{
    double logDTime = Dloga_interval_ti(Ti_Current);
    return (timebin > 0 ? (1u << (unsigned) timebin) : 0 ) * logDTime;
}

References Dloga_interval_ti().

Referenced by blackhole_accretion_postprocess(), blackhole_feedback_copy(), cooling_direct(), get_helium_neutral_fraction_sfreff(), get_neutral_fraction_sfreff(), get_sfr_eeqos(), get_timestep_dloga(), hydro_copy(), hydro_ngbiter(), print_timebin_statistics(), run(), sfr_wind_copy(), test_dloga(), and winds_evolve().

Here is the call graph for this function:

Here is the caller graph for this function:

loga_from_ti()

double loga_from_ti

(

inttime_t

ti

)

Definition at line 223 of file timebinmgr.c.

{
    inttime_t lastsnap = ti >> TIMEBINS;
    if(lastsnap > NSyncPoints) {
        endrun(1, "Requesting snap %d, from ti %d, beyond last sync point %d\n", lastsnap, ti, NSyncPoints);
    }
    double last = SyncPoints[lastsnap].loga;
    inttime_t dti = ti & (TIMEBASE - 1);
    double logDTime = Dloga_interval_ti(ti);
    return last + dti * logDTime;
}

References Dloga_interval_ti(), endrun(), SyncPoint::loga, NSyncPoints, SyncPoints, TIMEBASE, and TIMEBINS.

Referenced by dti_from_dloga().

Here is the call graph for this function:

Here is the caller graph for this function:

OutputListAction()

int OutputListAction	(	ParameterSet *	ps,
		const char *	name,
		void *	data
	)

This function parses a string containing a comma-separated list of variables, each of which is interpreted as a double. The purpose is to read an array of output times into the code. So specifying the output list now looks like: OutputList 0.1,0.3,0.5,1.0

We sort the input after reading it, so that the initial list need not be sorted. This function could be repurposed for reading generic arrays in future.

Definition at line 31 of file timebinmgr.c.

{
    char * outputlist = param_get_string(ps, name);
    char * strtmp = fastpm_strdup(outputlist);
    char * token;
    int count;
 
    /* Note TimeInit and TimeMax not yet initialised here*/
 
    /*First parse the string to get the number of outputs*/
    for(count=0, token=strtok(strtmp,","); token; count++, token=strtok(NULL, ","))
    {}
/*     message(1, "Found %d times in output list.\n", count); */
 
    /*Allocate enough memory*/
    Sync.OutputListLength = count;
    int maxcount = sizeof(Sync.OutputListTimes) / sizeof(Sync.OutputListTimes[0]);
    if(maxcount > (int) MAXSNAPSHOTS)
        maxcount = MAXSNAPSHOTS;
    if(Sync.OutputListLength > maxcount) {
        message(1, "Too many entries (%d) in the OutputList, can take no more than %d.\n", Sync.OutputListLength, maxcount);
        return 1;
    }
    /*Now read in the values*/
    for(count=0,token=strtok(outputlist,","); count < Sync.OutputListLength && token; count++, token=strtok(NULL,","))
    {
        /* Skip a leading quote if one exists.
         * Extra characters are ignored by atof, so
         * no need to skip matching char.*/
        if(token[0] == '"')
            token+=1;
 
        double a = atof(token);
 
        if(a < 0.0) {
            endrun(1, "Requesting a negative output scaling factor a = %g\n", a);
        }
        Sync.OutputListTimes[count] = a;
/*         message(1, "Output at: %g\n", Sync.OutputListTimes[count]); */
    }
    myfree(strtmp);
    return 0;
}

References endrun(), fastpm_strdup(), MAXSNAPSHOTS, message(), myfree, name, sync_params::OutputListLength, sync_params::OutputListTimes, param_get_string(), and Sync.

Referenced by create_gadget_parameter_set().

Here is the call graph for this function:

Here is the caller graph for this function:

round_down_power_of_two()

inttime_t round_down_power_of_two

(

inttime_t

dti

)

Definition at line 286 of file timebinmgr.c.

{
    /* make dti a power 2 subdivision */
    inttime_t ti_min = TIMEBASE;
    int sign = 1;
    if(dti < 0) {
        dti = -dti;
        sign = -1;
    }
    while(ti_min > dti)
        ti_min >>= 1;
    return ti_min * sign;
}

References TIMEBASE.

Referenced by find_timesteps(), get_PM_timestep_ti(), init_timeline(), and test_dloga().

Here is the caller graph for this function:

set_sync_params()

void set_sync_params	(	int	OutputListLength,
		double *	OutputListTimes
	)

Definition at line 76 of file timebinmgr.c.

{
    int i;
    Sync.OutputListLength = OutputListLength;
    for(i = 0; i < OutputListLength; i++)
        Sync.OutputListTimes[i] = OutputListTimes[i];
}

References OutputListLength, sync_params::OutputListLength, sync_params::OutputListTimes, and Sync.

Referenced by setup().

Here is the caller graph for this function:

setup_sync_points()

void setup_sync_points	(	double	TimeIC,
		double	TimeMax,
		double	no_snapshot_until_time,
		int	SnapshotWithFOF
	)

Definition at line 97 of file timebinmgr.c.

{
    int i;
 
    qsort_openmp(Sync.OutputListTimes, Sync.OutputListLength, sizeof(double), cmp_double);
 
    if(NSyncPoints > 0)
        myfree(SyncPoints);
    SyncPoints = (SyncPoint *) mymalloc("SyncPoints", sizeof(SyncPoint) * (Sync.OutputListLength+2));
 
    /* Set up first and last entry to SyncPoints; TODO we can insert many more! */
 
    SyncPoints[0].a = TimeIC;
    SyncPoints[0].loga = log(TimeIC);
    SyncPoints[0].write_snapshot = 0; /* by default no output here. */
    SyncPoints[0].write_fof = 0;
    SyncPoints[1].a = TimeMax;
    SyncPoints[1].loga = log(TimeMax);
    SyncPoints[1].write_snapshot = 1;
    if(SnapshotWithFOF)
        SyncPoints[1].write_fof = 1;
    else
        SyncPoints[1].write_fof = 0;
    NSyncPoints = 2;
 
    /* we do an insertion sort here. A heap is faster but who cares the speed for this? */
    for(i = 0; i < Sync.OutputListLength; i ++) {
        int j = 0;
        double a = Sync.OutputListTimes[i];
        double loga = log(a);
 
        for(j = 0; j < NSyncPoints; j ++) {
            if(a <= SyncPoints[j].a) {
                break;
            }
        }
        if(j == NSyncPoints) {
            /* beyond TimeMax, skip */
            continue;
        }
        /* found, so loga >= SyncPoints[j].loga */
        if(a == SyncPoints[j].a) {
            /* requesting output on an existing entry, e.g. TimeInit or duplicated entry */
        } else {
            /* insert the item; */
            memmove(&SyncPoints[j + 1], &SyncPoints[j],
                sizeof(SyncPoints[0]) * (NSyncPoints - j));
            SyncPoints[j].a = a;
            SyncPoints[j].loga = loga;
            NSyncPoints ++;
        }
        if(SyncPoints[j].a > no_snapshot_until_time) {
            SyncPoints[j].write_snapshot = 1;
            if(SnapshotWithFOF) {
                SyncPoints[j].write_fof = 1;
            }
            else
                SyncPoints[j].write_fof = 0;
        } else {
            SyncPoints[j].write_snapshot = 0;
            SyncPoints[j].write_fof = 0;
        }
    }
 
    for(i = 0; i < NSyncPoints; i++) {
        SyncPoints[i].ti = (i * 1L) << (TIMEBINS);
    }
 
/*     for(i = 0; i < NSyncPoints; i++) { */
/*         message(1,"Out: %g %ld\n", exp(SyncPoints[i].loga), SyncPoints[i].ti); */
/*     } */
}

References SyncPoint::a, cmp_double(), SyncPoint::loga, myfree, mymalloc, NSyncPoints, sync_params::OutputListLength, sync_params::OutputListTimes, qsort_openmp, Sync, SyncPoints, SyncPoint::ti, TIMEBINS, SyncPoint::write_fof, and SyncPoint::write_snapshot.

Referenced by init_timeline(), setup_density(), test_conversions(), test_dloga(), and test_skip_first().

Here is the call graph for this function:

Here is the caller graph for this function:

ti_from_loga()

inttime_t ti_from_loga

(

double

loga

)

Definition at line 236 of file timebinmgr.c.

{
    int i;
    int ti;
    /* First syncpoint is simulation start*/
    for(i = 1; i < NSyncPoints - 1; i++)
    {
        if(SyncPoints[i].loga > loga)
            break;
    }
    /*If loop didn't trigger, i == All.NSyncPointTimes-1*/
    double logDTime = (SyncPoints[i].loga - SyncPoints[i-1].loga)/TIMEBASE;
    ti = (i-1) << TIMEBINS;
    /* Note this means if we overrun the end of the timeline,
     * we still get something reasonable*/
    ti += (loga - SyncPoints[i-1].loga)/logDTime;
    return ti;
}

References SyncPoint::loga, NSyncPoints, SyncPoints, TIMEBASE, and TIMEBINS.

Referenced by dti_from_dloga(), init_timebins(), init_timeline(), test_conversions(), and test_dloga().

Here is the caller graph for this function:

Variable Documentation

NSyncPoints

int NSyncPoints

static

Definition at line 10 of file timebinmgr.c.

Referenced by Dloga_interval_ti(), find_current_sync_point(), find_next_sync_point(), loga_from_ti(), setup_sync_points(), and ti_from_loga().

Sync

struct sync_params Sync

static

Referenced by OutputListAction(), set_sync_params(), and setup_sync_points().

SyncPoints

SyncPoint* SyncPoints

static

table with desired sync points. All forces and phase space variables are synchonized to the same order.

Definition at line 9 of file timebinmgr.c.

Referenced by Dloga_interval_ti(), find_current_sync_point(), find_next_sync_point(), loga_from_ti(), setup_sync_points(), and ti_from_loga().