seg2.c

Go to the documentation of this file.

/*
 * This file is part of Titan2Reader
 *
 * Copyright (C) 2006, Sebastien Judenherc <sebastien.judenherc@agecodagis.com>
 * Copyright (C) 2008, Magnitude / Jérôme VERNIER <seismic.monitoring@wanadoo.fr>
 *
 * 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
 *
 */

/*
 * This file is maintained by Jérôme VERNIER
 * */

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <assert.h>
#include <sys/types.h>

#include "common.h" 

FILE *seg2ChannelFile[MAX_CHANNEL] = {
        NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
        NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
        NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
        NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
        NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
};

char seg2ChannelFileName[MAX_CHANNEL][128];

int KFULLSEG = 1;
// ------------------------------------------------------------
// JVE ADDS : File Identifior for unique SEG file containing all channels
// ------------------------------------------------------------
FILE *seg2File = NULL;
char seg2FileName[128];// name of the unique SEG file
int NbrChan=0; // Number of channels in the unique SEG file
int CurChan=0; // Current channel : must starts at zero instead of the variable "channel" which is a number between 0 and MAX_CHANNEL

int AddString(FILE *f, char *str)
{
        int16_t u16;
        if (str==NULL)
        {
                u16=0;
                fwrite(&u16,2,1,f);
                return(0);
        }
        // offset of the newt string
        u16=strlen(str)+3;
        fwrite(&u16,2,1,f);

        // write the string itself
        fwrite(str,1,u16-3,f);

        // termination char
        u16=0;
        fwrite(&u16,1,1,f);
        return(0);
}


int WriteFileDescriptorBlock(FILE *f)
{
        int16_t u16;
        int32_t u32;
        unsigned char u8;
        int i;
        int32_t firstTraceOffset;
        char string[512];
        struct tm tm;
        time_t T;
        int channel;

        channel =0;
        // magic
        u16=0x3a55;
        fwrite(&u16,2,1,f);
        // revision
        u16=1;
        fwrite(&u16,2,1,f);
        // size of the trace pointer subblock
        u16=(int16_t) 4*NbrChan; // JVE MODIFIIES : For writing "NbrChan" channels
        fwrite(&u16,2,1,f);
        // number of traces
        u16=(int16_t) NbrChan; // JVE MODIFIIES : For writing "NbrChan" channels
        fwrite(&u16,2,1,f);
        // number of string term
        u8=1;
        fwrite(&u8,1,1,f);
        // string term
        u8=0;
        fwrite(&u8,1,1,f);
        // unused
        u8=0;
        fwrite(&u8,1,1,f);
        // number of line term
        u8=1;
        fwrite(&u8,1,1,f);
        // line term
        u8='\n';
        fwrite(&u8,1,1,f);
        // unused
        u8=0;
        fwrite(&u8,1,1,f);
        // 14-31: unused
        u8=0;
        for (i=14; i<32; i++)
        {
                fwrite(&u8,1,1,f);
        }
        // remember this offset
        firstTraceOffset=ftell(f);
        // write a dummy offset.
        u32=0;
        for (i=1; i<=NbrChan; i++)
        {
        fwrite(&u32, 4, 1, f);
        }

        // now write the keywords
        // build the acquisition date and time strings
        T=(time_t)infoHeader[channel].correctedTime;
        strcpy(string,"ACQUISITION_DATE ");
        memcpy(&tm,gmtime(&T),sizeof(struct tm));
        strftime(string+strlen(string),64,"%d/%m/%Y",&tm);
        AddString(f, string);

        strcpy(string,"ACQUISITION_TIME ");
        strftime(string+strlen(string),64,"%H:%M:%S",&tm);
        AddString(f, string);
        sprintf(string,"ACQUISITION_TIME_US %6d",
                        (int)(1.e6*(infoHeader[channel].correctedTime-(double)T)));
        AddString(f, string);


        // ----------------------------------------------------
        // JVE MODIFICATION
        // ----------------------------------------------------
        // TRACE SORT IS A STRONGHLY RECOMMENDED
        // OPTION FOR TRACE SORT : AS_ACQUIRED,CDP_GATHER, CDP_STACK, COMMON_OFFSET
        // COMMON RECEIVER, COMMON_SOURCE..
        //by default : AS_ACQUIRED
        sprintf(string,"TRACE_SORT AS_ACQUIRED");
        AddString(f, string);

        // UNITS IS A STRONGHLY RECOMMENDED
        sprintf(string,"UNITS METERS");
        AddString(f, string);

        AddString(f, NULL);

        // adjust the current position to n*4 and note it
        u32=ftell(f);
        while (u32%4!=0)
        {
                u8=0;
                fwrite(&u8,1,1,f);
                u32=ftell(f);
        }
        // seek back to the offset of the first trace field
        fseek(f,firstTraceOffset,SEEK_SET);
        // write it
        fwrite(&u32, 4, 1, f);
        // seek to the first trace offset
        fseek(f,u32,SEEK_SET);
        return(0);
}

int UpdateFileDescriptorBlock(FILE *f,int channelS0)
{
        // This function is called just before writing TraceDescriptorBlock 
        // in order to know the position in the file of the TraceDescriptorBlock

        // this position is writted in the FileDescriptorBlock between byte 32 and 32+(Nchan-1)*4
        // where Nchan is the number of channel in the file
        int32_t u32;
        //byte position CUR
        u32 = ftell(f);
       // UPDATE FIELD "TRACE_START" FOR CHANNEL #"channel"  giving start position of the TraceDescriptorBlock
       // Go in the FileDescriptorBlock and write byte corresponding to TraceDescriptorBlock
       fseek(f,32+4*channelS0,SEEK_SET);
       fwrite(&u32,4,1,f);
       // Go bak to the byte position CUR
       fseek(f,u32,SEEK_SET);
       return(0);
}




// exemple : if we process channels 15 then 16 the 19 so,
// channel will be 15, 16 then 19 and channelS0 will be 0, 1, then 2
int WriteTraceDescriptorBlock(FILE *f, int channel)
{
        int16_t u16;
        int32_t u32;
        unsigned char u8;
        int i;
        int32_t blockSizeOffset;
        char string[512];

        // JVE MODIFIES : blockSizeOffset before writing magic number
        // remember the block size field offset
        blockSizeOffset=ftell(f);
        // magic
        u16=0x4422;
        fwrite(&u16,2,1,f);
        // write a dummy size
        u16=0;
        fwrite(&u16,2,1,f);
        // compute the data block length
        u32=infoHeader[channel].npts*4;
        fwrite(&u32,4,1,f);
        // number of samples
        u32=infoHeader[channel].npts;
        fwrite(&u32,4,1,f);
        // data format
        u8=2; // int32
        fwrite(&u8,1,1,f);
        // 13-31: unused
        u8=0;
        for (i=13; i<32; i++)
        {
                fwrite(&u8,1,1,f);
        }
        // keywords
        sprintf(string,"CHANNEL_NUMBER %2d",channel);
        AddString(f, string);

        // ----------------------------------------------------
        // JVE MODIFICATION
        // ----------------------------------------------------
        // DELAY : strongly recommended field
        sprintf(string,"DELAY %6f",0.0);
        AddString(f, string);

        //Adding descaling_factor in mV including gain : strongly recommended field
        sprintf(string,"DESCALING_FACTOR %6f",
                        HWConfig.LSB/(float)HWConfig.gain[HWConfig.selectedGain[channel]]/1000000.);
        AddString(f, string);
        // ----------------------------------------------------

        sprintf(string,"RAW_RECORD %s",currentFile);
        AddString(f, string);

        // ----------------------------------------------------
        // JVE MODIFICATION 
        // ----------------------------------------------------
        // RECEIVER_LOCATION : strongly recommended field
        sprintf(string,"RECEIVER_LOCATION %f %f %f",0.0,0.0,0.0);
        AddString(f, string);

        sprintf(string,"RECEIVER_NAME %s",infoHeader[channel].channel);
        AddString(f, string);

        // SAMPLE_INTERVAL : strongly recommended field
        sprintf(string,"SAMPLE_INTERVAL %6f",(double)infoHeader[channel].sr.div/(double)infoHeader[channel].sr.base);
        AddString(f, string);
        // ----------------------------------------------------

        AddString(f, NULL);

        // adjust the current position to n*4 and note it
        u32=ftell(f)-blockSizeOffset;
        while (u32%4!=0)
        {
               u8=0;
             fwrite(&u8,1,1,f);
             u32=ftell(f)-blockSizeOffset;
        }
        // seek back to the offset of the first trace field
        fseek(f,blockSizeOffset+2,SEEK_SET);
        // write it
        // JVE comments : traceDesriptorBlockSize must be writted in int16 format
        u16 = u32;
        fwrite(&u16, 2, 1, f);
        // back to the end of the TraceDescriptorBlock
        fseek(f,blockSizeOffset+u32,SEEK_SET);
        return(0);
}

FILE* OpenFullSeg2(char* path,int channel)
{
       if (seg2File==NULL)
       {
            // IF FILE DOES NOT EXIST, OPEN AND WRITE FILEDESCRIPTORBLOCK
            if (KFULLSEG)
            {
                    int fno=fileNameOptions;
                    // seg2 "full" filename does not need channel code, nor network name
                    fno&=~ADD_CHANNEL_CODE;
                    fno&=~ADD_NETWORK_CODE;
                    strcpy(path,FileName("", ".SEG", channel,fno));
                    PrintLog("OUTPUT: %s\n",path);
            }
            else
            {
                   strcpy(path,FileName("SINGLE", ".SEG", channel, fileNameOptions));
                  // NbrChan = 1;
            }
            assert( (seg2File = fopen(path,"wb")) !=NULL);
            WriteFileDescriptorBlock(seg2File);
       }
       return(seg2File);
}
FILE* OpenSeg2Channel(int channel)
{
        if (seg2ChannelFile[channel]==NULL)
        {
                int fd;
                strcpy(seg2ChannelFileName[channel],"titanfileXXXXXX");
                fd=OpenTempFile(seg2ChannelFileName[channel]);
                assert((seg2ChannelFile[channel]=fdopen(fd,"wb"))!=NULL);
                setvbuf(seg2ChannelFile[channel],NULL,_IOFBF,FILE_BUFFER_SIZE);

                if (seg2ChannelFile[channel])
                {
                         // Nombre de channels
                         NbrChan++;
                        // initialized a new generic header
                        InitInfoHeader(channel);
                }
                else
                {
                        PrintError("unable to open %s: %m\n",seg2ChannelFileName[channel]);
                }
        }
        return(seg2ChannelFile[channel]);
}

// note : fid has been closed because it was open in writting mode
// and has been reopen in reading mode
void AppendChannelToSeg2File(int channel,FILE* fid)
{
         int32_t *u32;
         assert((u32 = malloc(sizeof(int32_t)*infoHeader[channel].npts))!=NULL);
         fread(u32,sizeof(int32_t),infoHeader[channel].npts,fid);
         fwrite(u32,sizeof(int32_t),infoHeader[channel].npts,seg2File);
         free(u32);

}


void CloseFullSeg2File()
{
        if (seg2File==NULL)
        {
                return;
        }
        fclose(seg2File);
        seg2File = NULL;
        // When closing a Seg file containing all traces, reinits Number of channels and Current processed channel
        NbrChan = 0;
        CurChan = 0;
}


void CloseSeg2File(int channel)
{
        char line[128];
        char fulline[132];
        FILE* fid;


        if (seg2ChannelFile[channel]==NULL)
        {
                return;
        }
        if (KFULLSEG == 0)
        {
              NbrChan = 1;
        }
        // update the header information
        UpdateInfoHeader(channel);

        // and rewrite the header
        fclose(seg2ChannelFile[channel]);
        seg2ChannelFile[channel]=NULL;

        strcpy(line,FileName("", ".SEG2", channel, fileNameOptions));
        if (noWrite==0)
        {
               Rename(seg2ChannelFileName[channel],line);
        }

        // WRITE ONLY ONE SEG2
        OpenFullSeg2(fulline,channel);
        UpdateFileDescriptorBlock(seg2File,CurChan);
        WriteTraceDescriptorBlock(seg2File,channel);

        // ADDS DATA
        fid = fopen(line,"rb");
        if (fid==NULL)
        {
                PrintError("%s: %m\n",line);
        }
        assert( fid !=NULL );
        AppendChannelToSeg2File(channel,fid);
        fclose(fid);

        // DELETE ALL DATA FILES one per channel  
        unlink(line);
        unlink(seg2ChannelFileName[channel]);
        CurChan++;
        if (KFULLSEG == 0)
        {
              fclose(seg2File);
              seg2File = NULL;
              CurChan = 0;
        }
}

void AbortSeg2File(int channel)
{
        PrintDebug("abort for %s\n",seg2ChannelFileName[channel]);
        if (seg2ChannelFile[channel])
        {
                fclose(seg2ChannelFile[channel]);
                seg2ChannelFile[channel]=NULL;
                unlink(seg2ChannelFileName[channel]);
        }
}


void AddSeg2Data(int channel)
{
        if ((HWConfig.srObs[channel].npts==0)||(HWConfig.srExp[channel].npts==0))
        {
                return;
        }

        if (OpenSeg2Channel(channel))
        {
                int d;
                d=HWConfig.srObs[channel].npts;
                if (d!=fwrite(HWConfig.data[channel],4,d,seg2ChannelFile[channel]))
                {
                        PrintError("unable to write to %s: %m\n",
                                        seg2ChannelFileName[channel]);
                        AbortSeg2File(channel);
                }
                infoHeader[channel].npts+=d;

        }
}

---