otf.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 <fcntl.h>
#include <dirent.h>
#include <assert.h>
#include <signal.h>
#include <string.h>
#include <search.h>

#include "common.h"

// read input from stdin
// uint64_t trigger[MAXSTA];
// triggers contains the triggers for each station starting at T0.
// T0=bit0. T0-1=bit1 etc. bit0=now, bit63=63 seconds ago
// For each new time we shift all the values of trigger as long as T0
// is not the new time, for the station processed, we raise the LSB of
// the u_int64_t.
// For each new time, we mask the lower WINLEN bits of trigger values.
// After each new time added, we count how many trigger[i] are not 0.
// if the number of !=0 is larger than the minsta, we raise the
// global trigger.
// The time of the trigger is defined as T0-winlen/2.
// The maximum lenght of the window is 64 seconds.

// input format is:

// STA key time ... (otf file with the station name prepended)

#define MAXSTA 1024
int nsta=0;
char station[MAXSTA][16];
unsigned long long trigger[MAXSTA];
int windowLength=0;
int ignoreLength=0;
unsigned long long minsta=0;
time_t CT;
int timeDevider=1;

int ParseMergeTriggerOptions(char *cmd)
{
        char *s=cmd;
        int next,error;
        if (*s==0)
        {
                return(0);
        }
        if (*s!=',')
        {
                return(-1);
        }
        while (*s)
        {
                s++;
                next=0;
                error=1;
                if (strncmp(s,"i=",2)==0)
                {
                        if (sscanf(s+2,"%d%n",&ignoreLength,&next)!=1)
                        {
                                break;
                        }
                        // ok if >0
                        if (ignoreLength<1)
                        {
                                PrintError("ignore length must be positive\n");
                                return(-1);
                        }
                        while (ignoreLength/timeDevider>63)
                        {
                                timeDevider++;
                        }
                        PrintDebug("ignoreLength=%d\n",ignoreLength);
                        error=0;
                        next+=2;
                }
                if (strncmp(s,"w=",2)==0)
                {
                        if (sscanf(s+2,"%d%n",&windowLength,&next)!=1)
                        {
                                break;
                        }
                        // ok if >0
                        if (windowLength<1)
                        {
                                PrintError("window length must be positive\n");
                                return(-1);
                        }
                        while (windowLength/timeDevider>63)
                        {
                                timeDevider++;
                        }
                        PrintDebug("windowLength=%d\n",windowLength);
                        error=0;
                        next+=2;
                }
                if (strncmp(s,"m=",2)==0)
                {
                        if (sscanf(s+2,"%Lu%n",&minsta,&next)!=1)
                        {
                                break;
                        }
                        // larger than 0
                        if (minsta<1)
                        {
                                PrintError("minsta must be positive\n");
                                return(-1);
                        }
                        PrintDebug("minsta=%d\n",minsta);
                        error=0;
                        next+=2;
                }
                if (error)
                {
                        PrintError("could not parse trigger option string\n");
                        return(-1);
                }
                s+=next;
        }
        if ((minsta==0)||(windowLength==0))
        {
                return(-1);
        }
        if (ignoreLength<windowLength)
        {
                ignoreLength=windowLength;
        }
        return(0);
}


// find the index of the station. If the station cannot be found, create
// a new index for that station
// @param sta the station
// @return the index
int StationIndex(char *sta)
{
        int i;
        // station named '-' is the special station : already processed events
        if (sta[0]=='-')
        {
                return(MAXSTA-1);
        }
        for (i=0; i<nsta; i++)
        {
                if (0==strcmp(sta,station[i]))
                {
                        return(i);
                }
        }
        assert(i<MAXSTA-1);
        strcpy(station[i],sta);
        nsta++;
        return(i);
}

int MergeTriggers(char *cmd)
{
        char sta[16];
        time_t T;
        int i;
        int count;
        char key[16];
        unsigned long long mask,imask;
        char line[1024];
        int shift;
        if (ParseMergeTriggerOptions(cmd)<0)
        {
                return(-1);
        }
        // reset 
        memset(trigger,0,sizeof(unsigned long long)*MAXSTA);
        // mask
        mask=(1LL<<(windowLength/timeDevider))-1;
        imask=(1LL<<(ignoreLength/timeDevider))-1;
        // read input
        while (!feof(stdin))
        {
                // fetch one line
                if (NULL==fgets(line,1023,stdin))
                {
                        break;
                }
                // read station, type, time
                if (line[0]=='#')
                {
                        continue;
                }
                if (sscanf(line,"%s %s %ld",sta,key,&T)!=3)
                {
                        continue;
                }
                sta[15]=0;
                key[15]=0;
                // ignore if the type is not stalta
                if (0!=strcmp(key,"stalta"))
                {
                        continue;
                }
                shift=(T-CT)/timeDevider;
                // increase up to the station time, shift the table accordingly
                if (shift>63)
                {
                        // big jump in the future
                        memset(trigger,0,sizeof(unsigned long long)*MAXSTA);
                }
                else // small jump ?
                {
                        if (shift>0)
                        {
                                // small jump
                                for (i=0; i<nsta; i++)
                                {
                                        trigger[i]<<=shift;
                                }
                                trigger[MAXSTA-1]<<=shift;
                        }
                        else
                        {
                                // no jump at all
                        }
                }
                // update the current time
                CT=T;
                // raise the LSB for the current station
                i=StationIndex(sta);
                trigger[i]|=1ULL;
                // apply the mask on each station
                for (i=0; i<nsta; i++)
                {
                        trigger[i]&=mask;
                }
                trigger[MAXSTA-1]&=imask;
                // if the special station (index MAXSTA-1) is also triggering, ignore
                if (trigger[MAXSTA-1])
                {
                        continue;
                }
                // compute the number of active triggers
                count=0;
                for (i=0; i<nsta; i++)
                {
                        if (trigger[i])
                        {
                                count++;
                        }
                }
                // if the number of active triggers is above minsta
                if (count>=minsta)
                {
                        // generate an event
                        PrintError("TRIGGER : %d [%d/%Ld]: %.23s ",CT,count,minsta,time2str((double)CT));
                        for (i=0; i<nsta; i++)
                        {
                                if (trigger[i])
                                {
                                        fprintf(stderr," %s", station[i]);
                                }
                        }
                        fprintf(stderr,"\n");
                        // raise the trigger for station 1023
                        trigger[MAXSTA-1]|=1;
                        printf("- stalta %ld\n",CT);
                // endif
                }
        }
        return(0);
}

---