timebinmgr.h File Reference

#include "types.h"
#include "utils/paramset.h"

Include dependency graph for timebinmgr.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	SyncPoint

Macros
#define	TIMEBINS   20
#define	TIMEBASE   (1u<<TIMEBINS)
#define	MAXSNAPSHOTS   (1u<<(30-TIMEBINS))

Typedefs
typedef struct SyncPoint	SyncPoint

Functions
double	loga_from_ti (inttime_t ti)
inttime_t	ti_from_loga (double loga)
inttime_t	dti_from_dloga (double loga, const inttime_t Ti_Current)
double	dloga_from_dti (inttime_t dti, const inttime_t Ti_Current)
double	get_dloga_for_bin (int timebin, const inttime_t Ti_Current)
static inttime_t	dti_from_timebin (int bin)
inttime_t	round_down_power_of_two (inttime_t ti)
inttime_t	find_next_outputtime (inttime_t ti_curr)
inttime_t	out_from_ti (inttime_t ti)
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)
SyncPoint *	make_unplanned_sync_point (inttime_t ti)

Macro Definition Documentation

MAXSNAPSHOTS

#define MAXSNAPSHOTS   (1u<<(30-TIMEBINS))

Definition at line 15 of file timebinmgr.h.

TIMEBASE

#define TIMEBASE   (1u<<TIMEBINS)

Definition at line 14 of file timebinmgr.h.

TIMEBINS

#define TIMEBINS   20

< The simulated timespan is mapped onto the integer interval [0,TIMEBASE], where TIMEBASE needs to be a power of 2. Note that (1<<28) corresponds to 2^29. We allow some bits at the top of the integer timeline for snapshot outputs. Note that because each snapshot uses TIMEBASE on the integer timeline, the conversion factor between loga and ti is not constant across snapshots.

Definition at line 13 of file timebinmgr.h.

Typedef Documentation

SyncPoint

typedef struct SyncPoint SyncPoint

Definition at line 1 of file timebinmgr.h.

Function Documentation

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:

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:

dti_from_timebin()

static inttime_t dti_from_timebin ( int  bin )

inlinestatic

Definition at line 44 of file timebinmgr.h.

                                                  {
    /*Casts to work around bug in intel compiler 18.0*/
    return bin > 0 ? (1u << (unsigned) bin) : 0;
}

Referenced by apply_half_kick(), cooling_direct(), find_next_kick(), find_timesteps(), and is_timebin_active().

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_outputtime()

inttime_t find_next_outputtime

(

inttime_t

ti_curr

)

this function returns the next output time after ti_curr.

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:

make_unplanned_sync_point()

SyncPoint* make_unplanned_sync_point

(

inttime_t

ti

)

out_from_ti()

inttime_t out_from_ti

(

inttime_t

ti

)

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

ti

)

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: