GitLab

Very basic, stolen from my light bending code

When the output file exists and we don't overwrite it, we call
mpi_abort (if we can). If we can't the MPI runs into an error.
Not nice, but thats the best we can do.

Still lots of things to improve. But should be good enough
for mcmc investiagtions, probably not good enough for papers.

The missing indentation in binary search help causes that
searches for, e.g., 'where' find a match in here.

Indentation added.

When a chain file was continued or a new one created from an
old chain, it could happen, that walkers are outside of the
current parameter ranges (if they have been changed).

I added a check that tries to find enough valid parameter
combinations to run the chain from the restricted set.

The check for not matching number of walkers was wrong. No accesses
the proper struct.

In case the job crashed ( and was not just aborted ) although we
write the data to file, it seems that they are not recoverable in
the fits file. I added a close and open call after each cycle/elapsed
time to write the file boundaries properly. There is a fits function
doing this, but it is not implemented in the slang wrapper.

- Gaussian init could result in parameters outside of allowed parameter range.
  This is due to numerical issues. As a fix, move everything outside on the rim.

- The sigma qualifier was confusing, now corresponds directly to the parameter
  range such that a sigma of 1 is max-min, and sigma of 0.1 is (max-min)/10

* Keyword was previoiusly not read -> added to function
  get_sixte_xml_data

This does not solve the whole issue. Previous version of slang
allowed that Undefined_Types can be passed arround as long as they
are not actively used. Somthing like this was okay:

variable undefined_var;

define test (a,b)
{
  return a*100;
}

test(5, undefined_var);

The current devel version of slang throws an error as soon as the
undefined type interacts with the stack. So the above code is not
valid any more.

This will take some time probably. New slang version effectively
treats all undefined variables as errors. Yes, this renders the
Undefine_Type absolutely useless... So, variables can be declared
and not initialized, but as soon as the are used things will go
south. The proper way to test this is

__is_initialized(&potentiall_undefined_variable);

Yes, it takes a pointer. Fix here for optimal binning.

Oh, and, yes, this is a run time error. That means they will only
show up once in use...

Now pfold event case also respects the exact qualifier
and takes the differential phase grid change into account.
Otherwise constant period is assumed over one GTI frame
and the exposure time is equally distirbuted to the phase bins.
The exact code runs ~10 times slower.

We use 2d arrays to make the looping a bit more compact
and eventually improve the speed. But more importantly also
add an "exact" qualifier to the events caluclation. The not
exact branch assumes a constant dP over a GTI window.

Felix found an issue for fast periods (relative to GTI windows or LC
bins) where a huge performace penalty occured because we were looping
through each covered period one by one. For slow rotations/short
windows this is perfectly fine (and fast). To cover the case of fast
periods I changed the loop to go through all time frames of one phase
bin. Currently the change is applied if the time window covers more
than 5 phases. Might need some tweaking.

Sometimes the interpolation goes wrong and produces parameters
outside the parameter interval. This should be fixed more properly,
but for now we just calp it to the maximum if it is larger.

This problem is known as isis internally handles the parameters different
with a different order. Use __parameters instead.

Also, fixed a bug where cdf points are outside of parameter ranges. Fallback
to uniform distribution in this case.

When the cwd is not part of the load path --script does not find
relative files. To circumvent this we need to prepend a ./

add 'cont' qualifier as alias for 'continue'

Slang v2.3.1 and older did not allow keywords as unquoted field namse. The
implementation uses 'continue' as a qualifier and passed it arround like a
normal struct field. This caused problems with said older versions.
Changed to use get_struct_field/set_struct_field. Still the problem when
used as the qualifier to pass to emcee_hammer, but can be quoted like

emcee_hamme(; "continue");

* Commit 10c11aa5 removes the time lag error calculation from Uttley+14
  as it only differs from Nowak+99 in the normalization (signal PSD
  versus full PSD).
* Consequently, also the field in the lag-energy spectrum output file
  needs to be removed

* The lower bin should also be included, otherwise the minimal
  frequency bin (1/T) is never included in the calculation

Further notes:

* lag_energy_spectrum (and foucalc) filters the frequency range
  [fmin,fmax] and calculates the RMS in that range with the where
  function. This can potentially lead to underestimates of the RMS
  because bins where fmin/fmax is in between bin_lo and bin_hi are NOT
  counted.
* Example:
                                     fmin       fmax
User defined frequency filtering:     |           |
Frequency grid coming from DFT:    |   |   |   |   |
                                         X   X
only the two bins marked with X are accounted for in the RMS calculation.

* A potentially better implementation is to use an if statement to
  check whether most of the bin is below or above the frequency
  threshold and then decide to in-/exclude it.

* Uttley+14 calculate the coherence with the full power spectrum
  (noise + signal) in the denominator. This calculation was added in
  commit 4a64f55c.
* This calculation differs from the one in Nowak+99 Eq. 16.,
  Ingram+19 Eq. 21, or Vaughan&Nowak 97 Eq. 8 who divide by the SIGNAL
  power spectrum only.
* Thus, the Uttley+14 coherence will lead to a *smaller* value and
  thus bigger uncertainties on the time lag. That is, Uttley+14
  *overestimate* the uncertainties.
* This commit reverses 4a64f55c: It removes the Uttley+14 calculation.