LALApps 10.1.0.1-eeff03c
read.c
Go to the documentation of this file.
1/*
2* Copyright (C) 2007 Duncan Brown, Jolien Creighton, Robert Adam Mercer
3*
4* This program is free software; you can redistribute it and/or modify
5* it under the terms of the GNU General Public License as published by
6* the Free Software Foundation; either version 2 of the License, or
7* (at your option) any later version.
8*
9* This program is distributed in the hope that it will be useful,
10* but WITHOUT ANY WARRANTY; without even the implied warranty of
11* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12* GNU General Public License for more details.
13*
14* You should have received a copy of the GNU General Public License
15* along with with program; see the file COPYING. If not, write to the
16* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
17* MA 02110-1301 USA
18*/
19
20#include <config.h>
21#include <stdio.h>
22
23#include <FrameL.h>
24
25static const char *typestr( int type )
26{
27 switch ( type )
28 {
29 case FR_VECT_C:
30 return "char";
31 case FR_VECT_2S:
32 return "int_2";
33 case FR_VECT_4S:
34 return "int_4";
35 case FR_VECT_8S:
36 return "int_8";
37 case FR_VECT_1U:
38 return "unsigned char";
39 case FR_VECT_2U:
40 return "unsigned int_2";
41 case FR_VECT_4U:
42 return "unsigned int_4";
43 case FR_VECT_8U:
44 return "unsigned int_8";
45 case FR_VECT_4R:
46 return "float";
47 case FR_VECT_8R:
48 return "double";
49 case FR_VECT_C8:
50 return "complex";
51 case FR_VECT_C16:
52 return "double complex";
53 default:
54 return "unknown";
55 }
56 return "unknown";
57}
58
59static size_t typesize( int type )
60{
61 switch ( type )
62 {
63 case FR_VECT_C:
64 return sizeof( char );
65 case FR_VECT_2S:
66 return sizeof( short );
67 case FR_VECT_4S:
68 return sizeof( int );
69 case FR_VECT_8S:
70 return sizeof( FRLONG );
71 case FR_VECT_1U:
72 return sizeof( unsigned char );
73 case FR_VECT_2U:
74 return sizeof( unsigned short );
75 case FR_VECT_4U:
76 return sizeof( unsigned int );
77 case FR_VECT_8U:
78 return sizeof( FRULONG );
79 case FR_VECT_4R:
80 return sizeof( float );
81 case FR_VECT_8R:
82 return sizeof( double );
83 case FR_VECT_C8:
84 return 2 * sizeof( float );
85 case FR_VECT_C16:
86 return 2 * sizeof( double );
87 default:
88 return 0;
89 }
90 return 0;
91}
92
93static int writeFrVectData( FILE *fp, double x0, double dx, void *data,
94 size_t nobj, int type )
95{
96 size_t i;
97 switch ( type )
98 {
99 case FR_VECT_C:
100 for ( i = 0; i < nobj; ++i )
101 {
102 char *val = data;
103 /* NOTE: the line below will produce a compiler warning with
104 * certain versions of clang, this is a compiler bug; the code
105 * is correct */
106 fprintf( fp, "%e\t%hhd\n", x0 + i * dx, val[i] );
107 }
108 break;
109 case FR_VECT_2S:
110 for ( i = 0; i < nobj; ++i )
111 {
112 short *val = data;
113 fprintf( fp, "%e\t%d\n", x0 + i * dx, val[i] );
114 }
115 break;
116 case FR_VECT_4S:
117 for ( i = 0; i < nobj; ++i )
118 {
119 int *val = data;
120 fprintf( fp, "%e\t%d\n", x0 + i * dx, val[i] );
121 }
122 break;
123 case FR_VECT_8S:
124 for ( i = 0; i < nobj; ++i )
125 {
126 FRLONG *val = data;
127 fprintf( fp, "%e\t%ld\n", x0 + i * dx, (long)val[i] );
128 }
129 break;
130 case FR_VECT_1U:
131 for ( i = 0; i < nobj; ++i )
132 {
133 unsigned char *val = data;
134 fprintf( fp, "%e\t%c\n", x0 + i * dx, val[i] );
135 }
136 break;
137 case FR_VECT_2U:
138 for ( i = 0; i < nobj; ++i )
139 {
140 unsigned short *val = data;
141 fprintf( fp, "%e\t%hu\n", x0 + i * dx, val[i] );
142 }
143 break;
144 case FR_VECT_4U:
145 for ( i = 0; i < nobj; ++i )
146 {
147 unsigned int *val = data;
148 fprintf( fp, "%e\t%u\n", x0 + i * dx, val[i] );
149 }
150 break;
151 return sizeof( unsigned int );
152 case FR_VECT_8U:
153 for ( i = 0; i < nobj; ++i )
154 {
155 FRULONG *val = data;
156 fprintf( fp, "%e\t%lu\n", x0 + i * dx, (unsigned long)val[i] );
157 }
158 break;
159 case FR_VECT_4R:
160 for ( i = 0; i < nobj; ++i )
161 {
162 float *val = data;
163 fprintf( fp, "%e\t%e\n", x0 + i * dx, val[i] );
164 }
165 break;
166 case FR_VECT_8R:
167 for ( i = 0; i < nobj; ++i )
168 {
169 double *val = data;
170 fprintf( fp, "%e\t%e\n", x0 + i * dx, val[i] );
171 }
172 break;
173 case FR_VECT_C8:
174 for ( i = 0; i < nobj; ++i )
175 {
176 float *val = data;
177 fprintf( fp, "%e\t%e\t%e\n", x0 + i * dx, val[2*i], val[2*i+1] );
178 }
179 break;
180 case FR_VECT_C16:
181 for ( i = 0; i < nobj; ++i )
182 {
183 double *val = data;
184 fprintf( fp, "%e\t%e\t%e\n", x0 + i * dx, val[2*i], val[2*i+1] );
185 }
186 break;
187 default:
188 return -1;
189 }
190 return nobj;
191}
192
193static int writeFrVect( FILE *fp, struct FrVect *v )
194{
195 size_t size;
196 unsigned int dim;
197 char *ptr;
198 fprintf( fp, "# name = %s\n", v->name ? v->name : "" );
199 fprintf( fp, "# type = %s\n", typestr( v->type ) );
200 fprintf( fp, "# nData = %ld\n", (long)v->nData );
201 fprintf( fp, "# nDim = %d\n", v->nDim );
202 fprintf( fp, "# dims = %ld", (long)v->nx[0] );
203 for ( dim = 1; dim < v->nDim; ++dim )
204 fprintf( fp, ", %ld", (long)v->nx[dim] );
205 fprintf( fp, "\n" );
206 fprintf( fp, "# unitX = %s", v->unitX[0] ? v->unitX[0] : "" );
207 for ( dim = 1; dim < v->nDim; ++dim )
208 fprintf( fp, ", %s", v->unitX[dim] ? v->unitX[dim] : "" );
209 fprintf( fp, "\n" );
210 fprintf( fp, "# unitY = %s\n", v->unitY ? v->unitY : "" );
211 size = typesize( v->type );
212 ptr = v->data;
213 writeFrVectData( fp, v->startX[0], v->dx[0], ptr, v->nx[0], v->type );
214 ptr += size * v->nx[0];
215 for ( dim = 1; dim < v->nDim; ++dim )
216 {
217 fprintf( fp, "&\n" );
218 writeFrVectData( fp, v->startX[dim], v->dx[dim], ptr, v->nx[dim], v->type );
219 ptr += size * v->nx[dim];
220 }
221 return 1;
222}
223
224
225int main( int argc, char *argv[] )
226{
227 struct FrFile *frfile;
228 struct FrameH *frame;
229 char *fname;
230 char **channels;
231 int nchannels;
232 int retval = 1;
233
234 if ( argc < 3 )
235 {
236 fprintf( stderr, "usage: %s infilename channels\n", argv[0] );
237 return 1;
238 }
239
240 fname = argv[1];
241 channels = &argv[2];
242 nchannels = argc - 2;
243
244 FrLibIni( NULL, stderr, 0 );
245
246 if ( ! ( frfile = FrFileINew( fname ) ) )
247 return fputs( "file not found!\n", stderr ), 1;
248
249 while ( ( frame = FrameRead( frfile ) ) )
250 {
251 int chan;
252 for ( chan = 0; chan < nchannels; ++chan )
253 {
254 struct FrAdcData *adc;
255 struct FrProcData *proc;
256 struct FrSimData *sim;
257 char ofname[256];
258 FILE *fp;
259 if ( ( adc = FrAdcDataFind( frame, channels[chan] ) ) )
260 {
261 if ( frame->dt < 1 )
262 sprintf( ofname, "%s-%03u.dat", channels[chan], frame->frame );
263 else
264 sprintf( ofname, "%s-%u.dat", channels[chan], frame->GTimeS );
265 if ( ! ( fp = fopen( ofname, "w" ) ) )
266 return fprintf( stderr, "could not open output file %s!", fname ), 1;
267 fprintf( stderr, "writing to file %s\n", ofname );
268 fprintf( fp, "## name = %s\n", adc->name ? adc->name : "" );
269 fprintf( fp, "## comment = %s\n", adc->comment?adc->comment:"" );
270 fprintf( fp, "## crate = %u\n", adc->channelGroup );
271 fprintf( fp, "## channel = %u\n", adc->channelNumber );
272 fprintf( fp, "## bias = %f\n", adc->bias );
273 fprintf( fp, "## slope = %f\n", adc->slope );
274 fprintf( fp, "## units = %s\n", adc->units ? adc->units : "" );
275 fprintf( fp, "## sample rate (Hz) = %f\n", adc->sampleRate );
276 fprintf( fp, "## GPS time (s) = %u.%09u\n", frame->GTimeS,
277 frame->GTimeN );
278 /* fprintf( fp, "## time offset (s) = %u.%09u\n", adc->timeOffsetS,
279 adc->timeOffsetN ); */
280 fprintf( fp, "## freq shift (Hz) = %f\n", adc->fShift );
281 fprintf( fp, "## data valid = %s\n",
282 adc->dataValid ? "no" : "yes" );
283 if ( adc->data )
284 {
285 writeFrVect( fp, adc->data );
286 }
287 fclose( fp );
288 retval = 0;
289 }
290 else if ( ( proc = FrProcDataFind( frame, channels[chan] ) ) )
291 {
292 if ( frame->dt < 1 )
293 sprintf( ofname, "%s-%03u.dat", channels[chan], frame->frame );
294 else
295 sprintf( ofname, "%s-%u.dat", channels[chan], frame->GTimeS );
296 if ( ! ( fp = fopen( ofname, "w" ) ) )
297 return fprintf( stderr, "could not open output file %s!", fname ), 1;
298 fprintf( stderr, "writing to file %s\n", ofname );
299 fprintf( fp, "## name = %s\n",
300 proc->name ? proc->name : "" );
301 fprintf( fp, "## comment = %s\n",
302 proc->comment ? proc->comment : "" );
303 fprintf( fp, "## GPS time (s) = %u.%09u\n", frame->GTimeS,
304 frame->GTimeN );
305 fprintf( fp, "## freq shift (Hz) = %f\n", proc->fShift );
306 if ( proc->data )
307 {
308 writeFrVect( fp, proc->data );
309 }
310 fclose( fp );
311 retval = 0;
312 }
313 else if ( ( sim = FrSimDataFind( frame, channels[chan] ) ) )
314 {
315 if ( frame->dt < 1 )
316 sprintf( ofname, "%s-%03u.dat", channels[chan], frame->frame );
317 else
318 sprintf( ofname, "%s-%u.dat", channels[chan], frame->GTimeS );
319 if ( ! ( fp = fopen( ofname, "w" ) ) )
320 return fprintf( stderr, "could not open output file %s!", fname ), 1;
321 fprintf( stderr, "writing to file %s\n", ofname );
322 fprintf( fp, "## name = %s\n",
323 sim->name ? sim->name : "" );
324 fprintf( fp, "## comment = %s\n",
325 sim->comment ? sim->comment : "" );
326 fprintf( fp, "## GPS time (s) = %u.%09u\n", frame->GTimeS,
327 frame->GTimeN );
328 fprintf( fp, "## freq shift (Hz) = %f\n", sim->fShift );
329 if ( sim->data )
330 {
331 writeFrVect( fp, sim->data );
332 }
333 fclose( fp );
334 retval = 0;
335 }
336 else
337 {
338 fprintf( stderr, "warning: channel %s not found in frame %d\n", channels[chan], frame->frame );
339 }
340 }
341 FrameFree( frame );
342 }
343
344 FrFileIEnd( frfile );
345
346 return retval;
347}
ptr
ProcessParamsTable * ptr
char
#define char
fprintf
#define fprintf
data
sigmaKerr data[0]
i
int i
Definition: inspinj.c:596
type
type
size
size
proc
proc
int
int
float
float
main
int main(int argc, char *argv[])
Definition: read.c:225
writeFrVect
static int writeFrVect(FILE *fp, struct FrVect *v)
Definition: read.c:193
writeFrVectData
static int writeFrVectData(FILE *fp, double x0, double dx, void *data, size_t nobj, int type)
Definition: read.c:93
typesize
static size_t typesize(int type)
Definition: read.c:59
typestr
static const char * typestr(int type)
Definition: read.c:25
fname
CHAR fname[256]
Definition: spininj.c:211
ProcessParamsTable::type
CHAR type[LIGOMETA_TYPE_MAX]
fp
FILE * fp