time.c

Go to the documentation of this file.

/*
 * This file is part of Titan2Reader
 *
 * Copyright (C) 2006, Sebastien Judenherc <sebastien.judenherc@agecodagis.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *
 */

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <ctype.h>
#include <math.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>
#include <fcntl.h>
#include <dirent.h>

#include "common.h"

#define DTMAX1 5.e-3
#define DTMAX2 5.e-6

int fileNameOptions=ADD_CHANNEL_CODE; //<! channel naming options

char * auxChannelName[] = { "PwrSupply", "IntTemp", "AUX02", "AUX03", "AUX04", "AUX05", "AUX06", "AUX07", "AUX08",
                             "AUX09", "AUX10", "AUX11", "AUX12", "AUX13", "AUX14", "AUX15" };
char * auxChannelUnit[] = { "0.1V", "0.1°C", "count", "count", "count", "count", "count", "count",
                             "count", "count", "count", "count", "count", "count", "count", "count" };

int buggyMykerinos=0; //<! is current station a buggy mykerinos ?
int warnFixBuggyMykerinos=0; //<! not warned yet

char dayDirPrefix[255]; //<! the daydir prefix
int timeWarningNow=0; //<! a time warning occurred

struct InfoHeaderType infoHeader[MAX_CHANNEL]; //<! data header for each channel

struct Titan2TimeType lastExtTime = { 0, 0 }; //<! last pulse time
struct Titan2TimeType lastIntTime = { 0, 0 }; //<! last pulse
struct Titan2TimeType roundedTime = { 0, 0 }; //<! external time valid for titan1 and titan2

int knownUSecond=0; //<! have we seen an extend time frame ?
int knownSecond=0; //<! have we seen a time frame ?
int knownExtGps=0; //<! have we seen an GPS external time frame ?
int knownTime=0; //<! have we seen any time-related frame

FILE * dtFile=NULL;
char dtFileName[255];
struct Titan2TimeType dtFileTime = { 0, 0 }; //<! first time of the dt file
int dtUseLine;

double lastDt=1.e16; 

int nCached=0; 
double *dtCached=NULL; //<! internal cache management
double *TCached=NULL; //<! internal cache management
char dtCachedFile[255];

char testForStation[128]; //<! the station for which we are looking for a dt/dft file

int emptyDir=0; //<! 1 if absolutely NO dt file can be found in the dt directory

time_t lastShiftComputation=0; //<! last time for which we estimated the approx shift
double lastShiftComputed=0.0; //<! last computed approx shift

static int IsTitan1Time(void)
{
        if (((knownUSecond==0)||(knownExtGps==0))&&(knownTime==1)&&(knownSecond==1))
        {
                return(1);
        }
        return(0);
}


void ResetTimes(void)
{
        nCached=0;
        if (dtCached) { free(dtCached); dtCached=NULL; };
        if (TCached) { free(TCached); TCached=NULL; };

        emptyDir=0;
        knownTime=0;
        knownUSecond=0;
        knownSecond=0;
        knownExtGps=0;

        lastShiftComputation=0;
        lastShiftComputed=0.0;

        memset(&(HWConfig.digitizer),0,sizeof(struct DigitizerType));

        memset(&lastExtTime,0,sizeof(struct Titan2TimeType));
        memset(&lastIntTime,0,sizeof(struct Titan2TimeType));
        memset(&roundedTime,0,sizeof(struct Titan2TimeType));
        memset(&currentTime,0,sizeof(struct Titan2TimeType));
        memset(&correctedTime,0,sizeof(struct Titan2TimeType));
        memset(&pulseTime,0,sizeof(struct Titan2TimeType));
        memset(&gpsExtTime,0,sizeof(struct Titan2TimeType));
        memset(&gpsIntTime,0,sizeof(struct Titan2TimeType));
}

int InWindow(void)
{
        int bw;
        if (onlyTag[0])
        {
                if (strcmp(currentTag,onlyTag)!=0)
                {
                        return(0);
                }
        }
        if ((skipTime>beginWindow)&&(skipTime<endWindow))
        {
                bw=skipTime;
        }
        else
        {
                bw=beginWindow;
        }
        if (
                        (
                         !( 
                                 ((bw>0)&&(correctedTime.usecond>>32<bw))||
                                 ((endWindow>0)&&(correctedTime.usecond>>32>endWindow))
                                 )
                         )&&
                        ((currentTime.usecond>0)||(extractTit))
                        )
        {
                return(1);
        }
        return(0);
}


int DtFileSelect(const struct dirent* t)
{
        int l;
        char s[128];
        l=strlen(t->d_name);
        // reject short names
        if (l<strlen(testForStation)+4)
        {
                return(0);
        }
        strcpy(s,testForStation);
        strcat(s,".dft");
        // accept files ending with testForStation".dft"
        if (0==strcmp(t->d_name+l-strlen(testForStation)-4,s))
        {
                return(1);
        }
        strcpy(s,testForStation);
        strcat(s,".flt");
        // accept files ending with testForStation".dft"
        if (0==strcmp(t->d_name+l-strlen(testForStation)-4,s))
        {
                return(1);
        }
#ifndef IGNORE_DT_FILE
        strcpy(s,testForStation);
        strcat(s,".dt");
        // accept files ending with testForStation".dt"
        if (0==strcmp(t->d_name+l-strlen(testForStation)-3,s))
        {
                return(1);
        }
        // still here ? the file does not match
#endif
        return(0);
}

int ReadDtLine(char *line, double *T, double *dt, char *fn)
{
        if (6!=str2time(line,T))
        {
                PrintError("format error in %s: %s",fn,line);
                return(-1);
        }
        if (1!=sscanf(line,"%*s %lf",dt))
        {
                //PrintError("format error in %s: %s", fn,line);
                return(-1);
        }
        return(0);
}

int TimeFileSort(const void * a, const void * b)
{
        struct dirent **e1 = (struct dirent **)a;
        struct dirent **e2 = (struct dirent **)b;
        int l1,l2;
        l1=strlen((*e1)->d_name);
        l2=strlen((*e2)->d_name);
        // if the extension is the same
        if (strcmp((*e1)->d_name+l1-3,(*e2)->d_name+l2-3)==0)
        {
                // return the regular comparison result
                return(__alphasort(e1,e2));
        }

        // if a is "dft", then a is the first (-1)
        if (strcmp((*e1)->d_name+l1-3,"dft")==0)
        {
                return(-1);
        }
        // if b is "dt", then a is the first (-1)
        if (strcmp((*e2)->d_name+l2-2,"dt")==0)
        {
                return(-1);
        }
        // if b is "dft", then b is the first (1)
        if (strcmp((*e2)->d_name+l2-3,"dft")==0)
        {
                return(1);
        }
        // if a is "dt", then b is the first (1)
        if (strcmp((*e1)->d_name+l1-2,"dt")==0)
        {
                return(1);
        }
        // the flt case does not need to be examined
        return(0);
}

void FillDtCache(char *fileName)
{
        FILE *f;
        char line[128];
        int nalloc=0;
        double T,dt;
        PrintLog("reading '%s' for dt cache\n",fileName);
        strcpy(dtCachedFile,fileName);

        if (dtCached) { free(dtCached); dtCached=NULL; };
        if (TCached) { free(TCached); TCached=NULL; };
        nCached=0;

        f=fopen(fileName,"rt");
        if (!f)
        {
                return;
        }

        while (fgets(line,127,f)!=NULL)
        {
                if (line[0]=='#')
                {
                        continue;
                }
                if (nCached>=nalloc-1)
                {
                        nalloc+=4096;
                        dtCached=(double *)realloc(dtCached,nalloc*sizeof(double));
                        if (dtCached==0)
                        {
                                PrintError("realloc dtCached: %m\n");
                        }
                        TCached=(double *)realloc(TCached,nalloc*sizeof(double));
                        if (TCached==0)
                        {
                                PrintError("realloc TCached: %m\n");
                        }
                }
                // read the line
                if (0==ReadDtLine(line,&T,&dt,fileName))
                {
                        dtCached[nCached]=dt;
                        TCached[nCached] =T;
                        nCached++;
                }
        }
        fclose(f);
}

int GetInterpolatedShift(double t, double *ts, int *age, char *station, char *file)
{
        int ok=NO_TIME_CORRECTION,i,l,j;
        int nfiles=0;
        int notFoundInCache=1;
        char line[129];
        char dtfilename[255];
        FILE *f;
        double T1,T2,dt1,dt2,dt;
        struct dirent **dtfile=NULL;
        T1=-1.;
        T2=1.e20;
        dt1=dt2=dt=0.0;

        if (0!=strcmp(testForStation,station))
        {
                emptyDir=0;
                strcpy(testForStation,station);
        }
        // if we already know that no dt file can be found, skip that
        if (emptyDir!=0)
        {
                return(ok);
        }
        // if the time is in the cache
        if (nCached>0)
        {
                if ((TCached[0]<=t)&&(TCached[nCached-1]>=t))
                {
                        register int i;
                        // find the last T before
                        for (i=0; i<nCached; i++)
                        {
                                if (TCached[i]>t)
                                {
                                        if (i) i--;
                                        T1=TCached[i];
                                        dt1=dtCached[i];
                                        // find the first T after
                                        for (; i<nCached; i++)
                                        {
                                                if (TCached[i]>t)
                                                {
                                                        T2=TCached[i];
                                                        dt2=dtCached[i];
                                                        // work with cache
                                                        notFoundInCache=0;
                                                        if (file)
                                                        {
                                                                strcpy(file,dtCachedFile);
                                                        }
                                                        i=nCached;
                                                        break;
                                                }
                                        }
                                }
                        }
                }
        }
        // else
        if (notFoundInCache)
        {
                // for each dt file in the current directory:
                // any file named *.STATION.dft, *.STATION.flt, or *.STATION.dt (in that order)
                nfiles=__scandir(TDBPath(TDB_PATH_DFT,station),&dtfile,DtFileSelect,TimeFileSort);
                PrintDebug("scanning '%s' for '%s' ...%d\n",TDBPath(TDB_PATH_DFT,station),station,nfiles);
                if (nfiles==0)
                {
                        emptyDir=1;
                        return(ok);
                }
                for (i=0; i<nfiles; i++)
                {
                        sprintf(dtfilename,"%s/%s",TDBPath(TDB_PATH_DFT,station),dtfile[i]->d_name);
                        // open the file
                        f=fopen(dtfilename,"rt");
                        if (!f)
                        {
                                PrintError("%s: %m\n",dtfilename);
                                continue;
                        }
                        l=0;
                        // read the first valid
                        for (j=0; (l<5)&&(fgets(line,127,f)!=NULL); )
                        {
                                if (line[0]=='#')
                                {
                                        continue;
                                }
                                if (ReadDtLine(line,&T1,&dt1,dtfilename)<0)
                                {
                                        continue;
                                }
                                break;
                        }
                        // if the begin of the file is after t
                        if (T1>t)
                        {
                                // close the file
                                fclose(f);
                                // skip this file
                                break;
                                // endif
                        }
                        // seek to 1000bytes before the end of the file
                        fseek(f,SEEK_END,-1000);
                        // read a line
                        fgets(line,127,f);
                        // read the rest of the file and find the last time
                        while (fgets(line,127,f)!=NULL)
                        {
                                if (line[0]=='#')
                                {
                                        continue;
                                }
                                // find the earliest T(=T2) after t
                                if (ReadDtLine(line,&T2,&dt,dtfilename)<0)
                                {
                                        continue;
                                }
                        }
                        // close the file
                        fclose(f);
                        // if t is in the file
                        if ((T1<t)&&(T2>t))
                        // then
                        {
                                // copy the entire file in the cache
                                FillDtCache(dtfilename);
                                // then scan the cache to find T1<t<T2

                                // find the last T before
                                for (i=0; i<nCached; i++)
                                {
                                        if (TCached[i]>t)
                                        {
                                                if (i) i--;
                                                T1=TCached[i];
                                                dt1=dtCached[i];
                                                // find the first T after
                                                for (; i<nCached; i++)
                                                {
                                                        if (TCached[i]>t)
                                                        {
                                                                T2=TCached[i];
                                                                dt2=dtCached[i];
                                                                // work with cache
                                                                notFoundInCache=0;
                                                                if (file)
                                                                {
                                                                        strcpy(file,dtCachedFile);
                                                                }
                                                                i=nCached;
                                                                break;
                                                        }
                                                }
                                        }
                                }
                                // stop
                                break;
                        // endif
                        }
                // end for
                }
        // end if (time in the cahce)
        }
        PrintDebug("T1=%f t=%f T2=%f\n",T1,t,T2);

        // if T1 AND T2 could be found
        if ((T1>0.)&&(T2<1.e18))
        // then
        {
                // dt=(t-T1)*(dt2-dt1)/(T2-T1)
                *ts=dt1+(t-T1)*(dt2-dt1)/(T2-T1);
                // ok=1
                ok=INTERPOLATION_CORRECTION;
                *age=(int)(t-T1);
        // endif
        }
        else
        {
                // if we are before the first pulse
                if (T2<1.e18)
                {
                        ok=EXTENDED_CORRECTION;
                        *age=(int)(t-T2); // will probably be negative
                        *ts=dt2;
                }
                // if we are after the last pulse
                if (T1>0.)
                {
                        ok=EXTENDED_CORRECTION;
                        *age=(int)(T1-t);
                        *ts=dt1;
                }
        }
        // free the allocated buffers
        if (nfiles>0)
        {
                for (i=0; i<nfiles; i++)
                {
                        free(dtfile[i]);
                }
                free(dtfile);
        }
        PrintDebug("ok=%d ts=%f age=%d\n",ok,*ts,*age);
        return(ok);
}

double GetExtraTcorr(struct InfoHeaderType *ih)
{
        char fn[128];
        char line[128];
        double delay;
        FILE *f;
        // supposer qu'on ne connaît pas ce cas
        ih->extraTcorrUsed=0;
        // si un fichier de dérive n'a pas été utilisé, on sort
        if (strlen(ih->driftFile)==0)
        {
                return(0.0);
        }

        // déterminer quel fichier ouvrir
        sprintf(line,"%s/extra_tcorr",TDBPath(TDB_PATH_TC,ih->station));
        // ouvrir le fichier
        f=fopen(line,"rt");
        // si ok
        if (f!=NULL)
        {
                // tant qu'on peut encore lire
                while (!feof(f))
                {
                        // lire une ligne
                        if (NULL==fgets(line,79,f))
                        {
                                break;
                        }
                        // ignorer les commentaires et le formats faux
                        // extraire le nom de fichier et le délai
                        if ((line[0]=='#')||(2!=sscanf(line,"%s %lf",fn,&delay)))
                        {
                                continue;
                        }
                        // si le nom de fichier correspond à celui qui est utilisé
                        if (strcmp(ih->driftFile,fn)==0)
                        {
                                // fermer le fichier
                                fclose(f);
                                // lever le flag dans la structure
                                ih->extraTcorrUsed=1;
                                // retourner le délai lu
                                return(delay);
                        // finsi
                        }
                // fin tant
                }
        // fin si
        }
        // retourner 0
        return(0.0);
}

// this is to allow some more correction from a localfile named FrameSkip.STA
// lecture du fichier FrameSkip.station pour une correction supplémentaire
double GetFrameSkip(double starttime,char * station)
{
        // supposer la correction nulle
        double correction=0.0,tdate,c;
        char fn[128],line[80],sdate[50];
        FILE *f;
        // contruire le nom du fichier à lire
        sprintf(fn,TDBPath(TDB_PATH_TC,station),"/FrameSkip.%s",station);
        f=fopen(fn,"rt");
        // si le fichier existe
        if (f!=NULL)
        // alors
        {
                // tant qu'on est pas à la fin du fichier
                while (!feof(f))
                {
                        // lire une ligne
                        if (NULL==fgets(line,79,f))
                        {
                                break;
                        }
                        // ignorer les commentaires et le formats faux
                        if ((line[0]=='#')||(2!=sscanf(line,"%s %lf",sdate,&c)))
                        {
                                continue;
                        }
                        tdate=1.e38;
                        // lire la date et la correction
                        if (3>str2time(sdate, &tdate))
                        {
                                continue;
                        }
                        // si la date lue est antérieure à starttime
                        if (tdate<starttime)
                        // alors
                        {
                                // la correction est la correction lue
                                correction=c;
                        // finsi
                        }
                // fin tant
                }
                // fermer le fichier
                fclose(f);
        // finsi
        }
        if (fabs(correction)>0.1)
        {
                PrintWarning("%s: %.4fs observed delay (%.0f %.0f)\n",
                                fn,correction,tdate,starttime);
        }
        // retourner la correction
        return(correction);
}

double ADCDelay(struct DigitizerType *digitizer, int ch)
{
        // do not compute anything for aux channels
        if (ch>=MAX_OSIRIS_CHANNEL)
        {
                return(0.0);
        }
        if ((digitizer->ok)&&(!IsTitan1Time()))
        {
                if (digitizer->adcDelay<0.1)
                {
                        // in this case, the ADC is a 1251 !
                        return(2.5/16000.);
                }
                else
                {
                        return((double)digitizer->adcDelay/(double)digitizer->adcFrequency);
                }
        }
        else
        {
                int mch=PrimaryChannel(ch);
                return(
                                ((double)digitizer->adcDelay*(double)infoHeader[mch].sr.div)/
                               (double)infoHeader[mch].sr.base
                                );
        }
}

double Titan1FilterDelayTime(int ch)
{
        double fprim;
        double delay;
        int R;
        // do not compute anything for aux channels
        if (ch>=MAX_OSIRIS_CHANNEL)
        {
                return(0.0);
        }
        delay=0.0;
        if (ch<6)
        {
                return(0.0);
        }
        if (oldHWConfig.srExp[ch-6].div<=0)
        {
                return(0.0);
        }
        // set the initial frequency
        fprim=(double)oldHWConfig.srExp[ch-6].base/(double)oldHWConfig.srExp[ch-6].div;
        // set the initial ratio
        R=oldHWConfig.srExp[ch-6].base*oldHWConfig.srExp[ch].div/
                (oldHWConfig.srExp[ch-6].div*oldHWConfig.srExp[ch].base);
        while ((R!=0)&&((R%2)==0))
        {
                delay+=(double)(128-1)/(2.*(double)(fprim));
                R/=2;
                fprim/=2.0;
        }
        return(delay);
}

double FixBuggyMykerinos(struct DigitizerType *d, double f)
{
        // if the station is not Mykerinos
        if (d->adcDecimationLength!=0)
        {
                // the fix is not necessary
                return(0.0);
        }
        // else
        if (buggyMykerinos)
        {
                // if not already warned
                if (warnFixBuggyMykerinos==0)
                // then
                {
                        // warn !
                        PrintWarning("Mykerinos-T generates Titan2 data version (%d.%d.%d) with timing error that have been fixed. The data created by rtitan2 are corrected but the Mykerinos-T should be upgraded.\n",
                                        HWConfig.formatVersion,
                                        HWConfig.formatMajor,
                                        HWConfig.formatMinor);
                        // warnFixBuggyMykerinos=1
                        warnFixBuggyMykerinos=1;
                // endif
                }
                return(2.0/f);
        }
        // endif
        return(0.0);
}

void SetBuggyMykerinos(int yes)
{
        buggyMykerinos=yes;
}

double FilterDelayTime(struct DigitizerType *digitizer, struct Titan2SRType *sr, int ch)
{
#define ONE 1
        int fprim,R;
        double delay;

        // do not compute anything for aux channels
        if (ch>=MAX_OSIRIS_CHANNEL)
        {
                return(0.0);
        }

        if (digitizer->adcFrequency<=0)
        {
                return(Titan1FilterDelayTime(ch));
        }

        delay=0.;
        if (sr->npts==0)
        {
                PrintError("cannot compute a filter delay with F=0\n");
                timeWarningNow=1;
                timeWarning++;
                return(0.0);
        }
        // then the titan2 case
        // first fprim, if defined
        if ((digitizer->adcDecimation)&&(digitizer->adcDecimationLength>1))
        {
                // compute the delay for the first filter
                delay+=(double)(digitizer->adcDecimationLength-ONE)/
                        (2.*(double)digitizer->adcFrequency);
        }

        // determine the decimations 1/5 and 1/2 that lead to the f, starting
        // from fprim=freq0/decim0

        // where we start:
        fprim=digitizer->adcFrequency;
        if (digitizer->adcDecimation)
        {
                fprim/=digitizer->adcDecimation;
        }

        // now compute the delays for the 1/2 and 1/5 decimations

        // R=fprim/f
        R=fprim/sr->npts;
        // 1/5
        while ((R!=0)&&((R%5)==0))
        {
                delay+=(double)(digitizer->secondDecimationLength-ONE)/(2.*(double)(fprim));
                delay+=FixBuggyMykerinos(digitizer,fprim);
                R/=5;
                fprim/=5;
        }
        // 1/2
        while ((R!=0)&&((R%2)==0))
        {
                delay+=(double)(digitizer->secondDecimationLength-ONE)/(2.*(double)(fprim));
                delay+=FixBuggyMykerinos(digitizer,fprim);
                R/=2;
                fprim/=2;
        }
        return(delay);
}

unsigned int FilterChain(struct DigitizerType *digitizer, struct Titan2SRType *sr, int ch)
{
        int fprim,R;
        unsigned int ret;

        if (digitizer->adcFrequency<=0)
        {
                return(0);
        }

        if (sr->npts==0)
        {
                return(0);
        }
        // first fprim, if defined
        if ((digitizer->adcDecimation)&&(digitizer->adcDecimationLength>1))
        {
                ret=1;
        }
        else
        {
                ret=0;
        }
        ret<<=8;

        // determine the decimations 1/5 and 1/2 that lead to the f, starting
        // from fprim=freq0/decim0

        // where we start:
        fprim=digitizer->adcFrequency;
        if (digitizer->adcDecimation)
        {
                fprim/=digitizer->adcDecimation;
        }

        // now compute the delays for the 1/2 and 1/5 decimations

        // R=fprim/f
        R=fprim/sr->npts;
        // 1/5
        while ((R!=0)&&((R%5)==0))
        {
                R/=5;
                fprim/=5;
                ret++;
        }
        ret<<=8;
        // 1/2
        while ((R!=0)&&((R%2)==0))
        {
                R/=2;
                fprim/=2;
                ret++;
        }
        return(ret);
}


int CorrectTime(double t, struct InfoHeaderType *header)
{
        int ret;

        ret=NO_TIME_CORRECTION;
        if (header->pulse.usecond<=0)
        {
                // save the pulse time
                memcpy(&(header->pulse),&pulseTime,sizeof(struct Titan2TimeType));
                // save the external pulse time
                memcpy(&(header->external),&roundedTime,sizeof(struct Titan2TimeType));
        }

        if (header->pulse.usecond>0)
        {
                header->otshift=DiffTimeT2T1(&(header->external),&(header->pulse),NULL);
        }
        else
        {
                header->otshift=DiffTimeT2T1(&(header->external),&(header->pulse),NULL);
                header->tshift=header->otshift=0.0;
        }
        // fetch the time shift for the given time using the requested method
        switch (header->correctionMethod)
        {
                case AUTO_CORRECTION:
                case INTERPOLATION_CORRECTION:
                        ret=header->correctionMethod;
                        // use an interpolation, this requires the total time drift
                        // to be known (cache or dt file)
                        if (GetInterpolatedShift(t,
                                                &(header->tshift),
                                                &(header->pulseAge),
                                                header->station,
                                                header->driftFile)!=NO_TIME_CORRECTION)
                        {
                                break;
                        }
                        else
                        {
                                if (header->correctionMethod!=AUTO_CORRECTION)
                                {
                                        PrintWarning("could not interpolate the time "
                                                        "shift, falling back to "
                                                        "LAST_PULSE_CORRECTION\n");
                                }
                        }
                        // use the last pulse
                case LAST_PULSE_CORRECTION:
                        // ICI tester le cas où la correction est impossible
                        if (header->pulse.usecond>0)
                        {
                                ret=header->correctionMethod;
                                header->tshift=header->otshift;
                                break;
                        }
                case NO_TIME_CORRECTION:
                        if (header->correctionMethod!=NO_TIME_CORRECTION)
                        {
                                if (extractingData!=0)
                                {
                                        PrintWarning("no time correction could be performed\n");
                                }
                        }
                        ret=NO_TIME_CORRECTION;
                        header->tshift=0.0;
        }
        if ((header->correctionMethod!=ret)&&(header->correctionMethod!=NO_TIME_CORRECTION))
        {
                if (extractingData!=0)
                {
                        PrintWarning("could not apply the requested correction method\n");
                        timeWarningNow=1;
                        timeWarning++;
                }
        }
        return(ret);
}

double GetApproximatedShift(void)
{
        struct InfoHeaderType header;
        int i;
        if (HWConfig.fieldIdent[0]==0)
        {
                return(0.0);
        }
        if (abs((currentTime.usecond>>32)-lastShiftComputation)<3600)
        {
                return(lastShiftComputed);
        }
        lastShiftComputation=currentTime.usecond>>32;
        memset(&header,0,sizeof(struct InfoHeaderType));
        if (saveShift)
        {
                header.correctionMethod=LAST_PULSE_CORRECTION;
        }
        else
        {
                header.correctionMethod=AUTO_CORRECTION;
        }
        strcpy(header.station,HWConfig.fieldIdent);

        // save the pulse time
        memcpy(&(header.pulse),&pulseTime,sizeof(struct Titan2TimeType));
        // save the external pulse time
        memcpy(&(header.external),&roundedTime,sizeof(struct Titan2TimeType));
        // save the channel number
        i=CorrectTime(currentTime.usecond>>32, &header);
        lastShiftComputed=header.tshift;
        return(header.tshift);
}

double CorrectChannelStartTime(int ch)
{
        double T;
        T=US2S*(double)infoHeader[ch].uncorrected.usecond;

        // if the channel is a real one
        if (ch<MAX_OSIRIS_CHANNEL)
        {
                // compute the ADC delay
                infoHeader[ch].tadc=ADCDelay(&(oldHWConfig.digitizer),ch);

                // compute the filter delay
                infoHeader[ch].tfilter=FilterDelayTime(&(oldHWConfig.digitizer),&(infoHeader[ch].sr),ch);

                // fetch the corrected time
                infoHeader[ch].correctionMethod=CorrectTime(
                                (time_t)(infoHeader[ch].uncorrected.usecond>>32),
                                &(infoHeader[ch]));
                // compute the final time
                T-=infoHeader[ch].tadc;
                T-=infoHeader[ch].tfilter;
                if (noTimeCorrection==0)
                {
                        T-=infoHeader[ch].tshift;
                }
                infoHeader[ch].correctedTime=T;
        }
        // else the channel is a pseudo channel (1Hz, no correction)
        else
        {
                infoHeader[ch].correctedTime=floor(T+0.5);
        }
        return(T);
}

// determine the primary channel for a possibly secondary channel
// @param channel the channel
// @return the primary channel associated
int PrimaryChannel(int channel)
{
        if (IsTitan1Time())
        {
                return(channel>5)?(channel-6):channel;
        }
        else
        {
                return(channel);
        }
}

double DiffTimeT2T1(struct Titan2TimeType *t1, struct Titan2TimeType *t2, struct Titan2TimeType *td)
{
        double diff;
        if (td)
        {
                td->usecond=t2->usecond-t1->usecond;
                diff=US2S*(double)td->usecond;
        }
        else
        {
                diff=US2S*(double)(t2->usecond-t1->usecond);
        }
        return(diff);
}

double TimeAdd(struct Titan2TimeType *t1, struct Titan2TimeType *t2, struct Titan2TimeType *ts)
{
        ts->usecond=t1->usecond+t2->usecond;
        return(