/* $Header: /scisoft/gildas/sou/nic/main/nic_nmbio.c,v 1.9 2000/02/10 11:25:27 broguier Exp $ */ /* $Log: nic_nmbio.c,v $ * Revision 1.9 2000/02/10 11:25:27 broguier * add 0 before scan number (if < 1000) * * Revision 1.8 99/11/30 19:08:47 19:08:47 broguier () * add some void to avoid warnings messages[ * * Revision 1.7 99/02/12 11:23:16 11:23:16 broguier (Dominique Broguiere) * COLSTAR %f * NPREHEADER=11 * || (data == '<') || (data == ',') * * Revision 1.6 98/12/22 17:25:19 17:25:19 broguier (Dominique Broguiere) * change type of colstar * * Revision 1.5 98/03/04 14:20:24 14:20:24 perrigou (Alain Perrigouard) * WIN32 * * Revision 1.2 96/03/19 15:18:07 15:18:07 gildas (Gildas manager) * F2C #define added. GD. * * Revision 1.8 95/06/09 15:00:26 15:00:26 broguier (Dominique Broguiere) * add line "#define getnmbrecord_old getnmbrecord_old_" * * Revision 1.7 95/06/01 09:46:36 09:46:36 broguier (Dominique Broguiere) * Modification of nmb records * * Revision 1.5 95/01/23 17:11:26 17:11:26 perrigou (Alain Perrigouard) * include for f2c * * Revision 1.1 94/11/07 17:13:30 17:13:30 broguier (Dominique Broguiere) * Initial revision * */ /**********************************************************************/ /* Created: 19. April 1990 */ /* Updated: <06-09-93 17:06> */ /* Updated: <06-09-93 15:01> buffered I/O removed GetNextByte */ /* changed */ /* Updated: 13-06-94 introduce wobbler information */ /* Updated: 18-06-94 modification in Write2Byte */ /* Updated: 07-11-94 input parameters of GetNmbRecord : */ /* ChanXdump becomes &ChanXdump */ /* Updated: 29-05-95 modify WriteRawData (scan_coord) */ /**********************************************************************/ #include #ifdef MSDOS #include #endif #include #include #include "nmb.h" #define BUFFERSIZE 33 /* Size of the Buffer */ #define CR 13 /* Carriage Return (dezimal) */ #define LF 10 /* Line Feed (dezimal) */ #define IBMEOF 26 /* IBM internal End of File */ #define EOR 22 /* Multi Byte End of Record */ #define DLEVEL 0 /* Define the Debug Level */ #define NPREHEADER 11 /* Number of lines in Preheader */ #ifdef WIN32 #define getheaderinformation _stdcall GETHEADERINFORMATION #define getnmbrecord GETNMBRECORD #define getnmbrecord_old _stdcall GETNMBRECORD_OLD #define findnoofsubscans _stdcall FINDNOOFSUBSCANS #define writeheaderinformation _stdcall WRITEHEADERINFORMATION #endif #ifdef underscore #define getheaderinformation getheaderinformation_ #define multibyteinput multibyteinput_ #define getnmbrecord getnmbrecord_ #define getnmbrecord_old getnmbrecord_old_ #define findnoofsubscans findnoofsubscans_ #define writeheaderinformation writeheaderinformation_ #endif #ifdef f2c #define getheaderinformation getheaderinformation_ #define multibyteinput multibyteinput_ #define getnmbrecord getnmbrecord_ #define getnmbrecord_old getnmbrecord_old__ #define findnoofsubscans findnoofsubscans_ #define writeheaderinformation writeheaderinformation_ #endif /***********************************************************************/ /* MultiByteInput: read from InputStream next Multi Byte Number or */ /* ============== next Multi Byte Text and check for Multi Byte End */ /* of File condition. */ /* return in the specified Variables Numbers, Strings */ /* or ErrorStautus = -1 if Multi Byte End of File */ /* occured. */ /* R. Lemke MPIfR April 1990 */ /***********************************************************************/ void MultiByteInput( MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus) int *MultiByteMode, /* the actual Multi Byte Mode */ *ErrorStatus; /* Error Status */ float *MultiByteNum; /* on return the deocded NMB Value */ char *MultiByteText; /* on return the decode NMB String */ FILE *InputStream; /* Input File Stream */ { int data, i; static RemaningByte = 0; float Byte1, Byte2, Byte3; int GetNextByte(); MultiByteText[0] = '\0'; *MultiByteNum = 0; if (!RemaningByte) /* No Remaning Byte */ RemaningByte = GetNextByte(InputStream, ErrorStatus); /* If End Of File found */ /*-----------------------------------------------------*/ if (*ErrorStatus == -1) { *MultiByteMode = 0; /* reset MultiByteMode */ RemaningByte = 0; /* no Remaning Byte to */ return; /* return */ } /*-----------------------------------------------------------------*/ /* check: is RemaningByte a new Control Byte */ /*-----------------------------------------------------------------*/ if (RemaningByte < 32) { /* yes, change the actual Multi Byte Mode */ *MultiByteMode = RemaningByte; RemaningByte = GetNextByte(InputStream, ErrorStatus); } /* no, Remaning Byte is a new Data Byte */ /*-----------------------------------------------------------------*/ /* process the actual Multi Byte Mode */ /*-----------------------------------------------------------------*/ switch (*MultiByteMode) { case 21: /*-----------------------------------------------------*/ /* Multi Byte Start Of File found, check Version */ /*-----------------------------------------------------*/ data = RemaningByte; if ((char)data != 'A') printf("NMBIO-W: Invalid Version\n"); RemaningByte = 0; /* no Remaning Byte to */ return; /* return */ case 23: /*-----------------------------------------------------*/ /* Multi Byte End Of File found */ /*-----------------------------------------------------*/ *ErrorStatus = -1; /* set Error Status */ *MultiByteMode = 0; /* reset MultiByteMode */ RemaningByte = 0; /* no Remaning Byte to */ return; /* return */ case 24: /*-----------------------------------------------------*/ /* Multi Byte Mode: 1 (1 Byte to process) */ /*-----------------------------------------------------*/ *MultiByteNum = (float)(RemaningByte - 32); RemaningByte = 0; /* no Remaning Byte to */ return; /* return */ case 25: /*-----------------------------------------------------*/ /* Multi Byte Mode: 2 (2 Bytes to process) */ /*-----------------------------------------------------*/ Byte1 = (float)(RemaningByte - 32); Byte2 = (float)(GetNextByte(InputStream, ErrorStatus) - 32); *MultiByteNum = Byte1 + Byte2 * 224.0; RemaningByte = 0; /* no Remaning Byte to */ return; /* return */ case 27: /*-----------------------------------------------------*/ /* Multi Byte Mode: 3 (3 Bytes to process) */ /*-----------------------------------------------------*/ Byte1 = (float)(RemaningByte - 32); Byte2 = (float)(GetNextByte(InputStream, ErrorStatus) - 32); Byte3 = (float)(GetNextByte(InputStream, ErrorStatus) - 32); *MultiByteNum = Byte1 + Byte2 * 224.0 + Byte3 * 50176.0 - 2.e6; RemaningByte = 0; /* no Remaning Byte to */ return; /* return */ case 28: /*-----------------------------------------------------*/ /* Multi Byte Text Mode */ /*-----------------------------------------------------*/ MultiByteText[0] = RemaningByte; i = 1; while (( (data = GetNextByte(InputStream, ErrorStatus)) == '>') || (data == '<') || (data == ',') || (data == '+') || (data == '_') || (data == '.') || (data == ' ') || (data == '-') || isalnum(data)) MultiByteText[i++] = (char) data; MultiByteText[i++] = '\0'; /* terminating String */ RemaningByte = data; /* Remaning Byte to */ return; /* return */ case 29: /*-----------------------------------------------------*/ /* Multi Byte Number Text Mode */ /*-----------------------------------------------------*/ MultiByteText[0] = RemaningByte; i = 1; while (( (data = GetNextByte(InputStream, ErrorStatus)) == '-') || (data == '.') || isdigit(data)) MultiByteText[i++] = (char) data; MultiByteText[i++] = '\0'; /* terminating String */ RemaningByte = data; /* Remaning Byte to */ return; /* return */ } } /**********************************************************************/ /* GetNextByte: get next Byte from stream */ /* =========== R. Lemke MPIfR April 1990 updated 1993 */ /**********************************************************************/ int GetNextByte(InputStream, ErrorStatus) FILE *InputStream; /* Input File Stream */ int *ErrorStatus; /* Error Status */ { int data, flag; if (InputStream == NULL) /* File Stream is not open ! */ { printf("NMBIO-E: File is not open\n"); *ErrorStatus = -1; exit(-1); } flag = 1; *ErrorStatus =0; while(flag) { data = fgetc(InputStream); switch(data) { case IBMEOF: *ErrorStatus = -1; flag = 0; break; case EOF: *ErrorStatus = -1; flag = 0; break; case CR: break; case LF: break; case EOR: break; default: flag = 0; } } return(data); } /**********************************************************************/ /* ScanHeaderInput: */ /* =============== */ /* */ /* R. Lemke MPIfR April 1990 */ /**********************************************************************/ void ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, Format, Argument) int *MultiByteMode, /* the actual Multi Byte Mode */ *ErrorStatus; /* Error Status */ float *MultiByteNum; /* on return the deocded NMB Value */ char *MultiByteText; /* on return the decode NMB String */ FILE *InputStream; /* Input File Stream */ char *Format; /* Format String for sscanf */ int *Argument; /* argument is passed by address, */ /* no problem for passing Floating */ /* Point values ! */ { MultiByteInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); sscanf(MultiByteText, Format, Argument); } /**********************************************************************/ /* GetHeaderInformation: */ /* ==================== */ /* */ /* R. Lemke MPIfR April 1990 */ /**********************************************************************/ #ifdef WIN32 void GetHeaderInformation (MultiByteMode, MultiByteNum, MultiByteText, length, Header, InputStream, ErrorStatus) int length; #else void GetHeaderInformation (MultiByteMode, MultiByteNum, MultiByteText, Header, InputStream, ErrorStatus) #endif int *MultiByteMode, /* the actual Multi Byte Mode */ *ErrorStatus; /* Error Status */ float *MultiByteNum; /* on return the deocded NMB Value */ char *MultiByteText; /* on return the decode NMB String */ FILE *InputStream; /* Input File Stream */ struct head *Header; /* Header Structure */ { int i, /* Loop Index */ Number = 0; char *EndOfHeader = "-99999"; char *p1,*p2; int len; int LengthOfEndOfHeader = (int)(strlen(EndOfHeader)); /*------------------------------------------------------------------*/ /* check for Start of File */ /*------------------------------------------------------------------*/ MultiByteInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); /*------------------------------------------------------------------*/ /* get Pre Header, until End of Pre Header "-99999" */ /*------------------------------------------------------------------*/ while (strncmp(MultiByteText,EndOfHeader, LengthOfEndOfHeader )!=0 && *ErrorStatus!=-1) { MultiByteInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); sprintf (Header->PreHeader[Number++], "%s", MultiByteText); } if (*ErrorStatus==-1) return; /*------------------------------------------------------------------*/ /* get Scan Number and Source Name */ /*------------------------------------------------------------------*/ MultiByteInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); sscanf(MultiByteText," %d", &Header->ScanNumber); p1 = strchr(MultiByteText+1,' '); while (*p1 ==' ') p1 +=1; p2 = strrchr(MultiByteText,' '); while (*p2 ==' ') p2 -=1; *(p2+1) = 0; strcpy(Header->SourceName,p1); len = strlen(Header->SourceName); for (i=0;iSourceName[i] ==' ') Header->SourceName[i]='_'; } /*------------------------------------------------------------------*/ /* get Frequency, Gain, Magnet Flag, #Channels and #Phases */ /*------------------------------------------------------------------*/ ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Frequency); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->Gain); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->Magnet); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->Channels); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->Phases); /*------------------------------------------------------------------*/ /* get Lambda Corrdinates and LAMSTAR Flag */ /*------------------------------------------------------------------*/ ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Lambda.S); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Lambda.O); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Lambda.V); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->Lambda.Star); /*------------------------------------------------------------------*/ /* get Beta Corrdinates */ /*------------------------------------------------------------------*/ ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Beta.S); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Beta.O); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Beta.V); /*------------------------------------------------------------------*/ /* get Azimuth Corrdinates and AZMSTAR Flag */ /*------------------------------------------------------------------*/ ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Azimuth.S); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Azimuth.O); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Azimuth.V); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->Azimuth.Star); /*------------------------------------------------------------------*/ /* get Elevation Corrdinates */ /*------------------------------------------------------------------*/ ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Elevation.S); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Elevation.O); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Elevation.V); /*------------------------------------------------------------------*/ /* get Secondary Parameters */ /*------------------------------------------------------------------*/ ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->SFC.X); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->SFC.Y); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->SFC.Z); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->SPH.X); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->SPH.Y); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->SPH.Z); /*------------------------------------------------------------------*/ /* get Sint, Basis Sytem, Epoch, DAZM */ /*------------------------------------------------------------------*/ ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->sint); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->sbas); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Epoch); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->DAZM); /*------------------------------------------------------------------*/ /* get SRP and Scan Direction Code */ /*------------------------------------------------------------------*/ for (i = 0; i <= 3; i++) ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->SRP[i]); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->SDC); /*------------------------------------------------------------------*/ /* get Weather */ /*------------------------------------------------------------------*/ ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Pressure); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Temperature); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Humidity); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->Refraction); /*------------------------------------------------------------------*/ /* get NULA, NULE, Col Star and Date of Observation */ /*------------------------------------------------------------------*/ ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->NULA); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->NULE); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->ColStar); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->Date.Year); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->Date.Month); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->Date.Day); /*------------------------------------------------------------------*/ /* get Wobbler information (if it exists) */ /*------------------------------------------------------------------*/ MultiByteInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); /* Multi Byte Number Text Mode is 29*/ if (*MultiByteMode==29) { sscanf(MultiByteText,"%d", &Header->WobblingDevice); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->WobblingAmpli); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%f", &Header->WobblingPeriod); ScanHeaderInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus, "%d", &Header->WobblingMode); MultiByteInput (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); } } void DisplaySubScans(top) struct subscans *top; { printf ("NMBIO-I: SubScan Number Epoch Start Time \n"); while(top) { printf("NMBIO-I: %3d %4.5f %5.4f \n", top->Number, top->Epoch, top->Time); top = top->next; } } void FindNoOfSubScans(top, NoOfSubScans) struct subscans *top; int *NoOfSubScans; { int i = 0; while(top) { i++; top = top->next; } *NoOfSubScans = i--; } void StoreSubScans(i) struct subscans *i; { static struct subscans *last = 0; if (last == 0) last = i; else last->next = i; i->next = 0; last = i; } /**********************************************************************/ /* DeriveChanXDump: Calculate Channels X Dumps, to get the actual */ /* =============== length of data records. */ /* If the number of Channels from PC and Vax are */ /* different a WARNING message will be printed, and */ /* it's assumed that the PC is right. */ /* R. Lemke MPIfR April 1990 */ /**********************************************************************/ void DeriveChanXDump (Channels, ChanXDump, Header) struct head *Header; /* the complete Header */ int *Channels; /* on return the Number of Channels */ int *ChanXDump; /* on return the Result of */ /* #Channels * #Dumps */ { int i = 0; int NoOfChannels, NoOfDumps; char *CHANNELS = ">CHANNELS %d"; char *DUMPS = ">DUMPS %d"; int LengthOfCHANNELS = (int)(strlen(CHANNELS)) - 3; int LengthOfDUMPS = (int)(strlen(DUMPS)) - 3; /*-------------------------------------------------------------------*/ /* find the CHANNELS string in the PreHeader, and extract the */ /* Number of Channels. */ /*-------------------------------------------------------------------*/ while (strncmp(Header->PreHeader[i++], CHANNELS, LengthOfCHANNELS)) { #if DLEVEL > 2 printf("DeriveChanXDump-D: i %d Header->PreHeader[i] %s\n", i, Header->PreHeader[i]); #endif } sscanf(Header->PreHeader[--i], CHANNELS, &NoOfChannels); #if DLEVEL > 2 printf ("DeriveChanXDump-D: NoOfChannels = %d\n",NoOfChannels); #endif /* check PC-VAX Informations about Number of Channels */ if (NoOfChannels != Header->Channels) { /* printf("DeriveChanXDump-W: No of channels PC-VAX differs, PC"); printf(" assumed to be right\n"); */ } /*-------------------------------------------------------------------*/ /* find the DUMPS string in the PreHeader, and extract the Number */ /* of Dumps. */ /*-------------------------------------------------------------------*/ while (strncmp(Header->PreHeader[i++], DUMPS, LengthOfDUMPS)) { #if DLEVEL > 2 printf("DeriveChanXDump-D: i= %d Header->PreHeader[i] = %s\n", i, Header->PreHeader[i]); #endif } sscanf(Header->PreHeader[--i], DUMPS, &NoOfDumps); #if DLEVEL > 2 printf ("DeriveChanXDump-D: NoOfDumps = %d\n", NoOfDumps); #endif /*-------------------------------------------------------------------*/ /* as a result of such a large Program, calculate #Channels * #Dumps*/ /*-------------------------------------------------------------------*/ *Channels = NoOfChannels; /* as seen by the PC */ *ChanXDump = NoOfChannels * NoOfDumps; #if DLEVEL > 2 printf ("DeriveChanXDump-D: ChanXDump = %d\n", *ChanXDump); #endif } #ifdef WIN32 void _stdcall GetNMBRecord (MultiByteMode, MultiByteNum, MultiByteText, length, InputStream, ChanXDump, NMBRecord, ErrorStatus) int length; #else void GetNMBRecord (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ChanXDump, NMBRecord, ErrorStatus) #endif int *MultiByteMode, /* the actual Multi Byte Mode */ *ErrorStatus; /* Error Status */ float *MultiByteNum; /* on return the deocded NMB Value */ char *MultiByteText; /* on return the decode NMB String */ FILE *InputStream; /* Input File Stream */ int *ChanXDump; struct nmbdata *NMBRecord; { int i; MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); if (*ErrorStatus == -1) return; NMBRecord->UT = *MultiByteNum / 30.0; MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); if (*ErrorStatus == -1) return; NMBRecord->Azimuth = *MultiByteNum / 7200.0; MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); if (*ErrorStatus == -1) return; NMBRecord->Elevation = *MultiByteNum / 7200.0; for (i = 0; i < 2; i++) { MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); if (*ErrorStatus == -1) return; NMBRecord->Scan_coord[i] = *MultiByteNum - 25000.0; } for (i = 0; i < *ChanXDump; i++) { MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); if (*ErrorStatus == -1) return; NMBRecord->Data[i] = *MultiByteNum - 25000.0; } } #ifdef WIN32 void GetNMBRecord_old (MultiByteMode, MultiByteNum, MultiByteText, length, InputStream, Chan,ChanXDump, NMBRecord, ErrorStatus) int length; #else void GetNMBRecord_old (MultiByteMode, MultiByteNum, MultiByteText, InputStream, Chan,ChanXDump, NMBRecord, ErrorStatus) #endif int *MultiByteMode, /* the actual Multi Byte Mode */ *ErrorStatus; /* Error Status */ float *MultiByteNum; /* on return the deocded NMB Value */ char *MultiByteText; /* on return the decode NMB String */ FILE *InputStream; /* Input File Stream */ int *ChanXDump; int *Chan; struct nmbdata *NMBRecord; { int i; MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); if (*ErrorStatus == -1) return; NMBRecord->UT = *MultiByteNum / 30.0; MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); NMBRecord->Azimuth = *MultiByteNum / 7200.0; MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); NMBRecord->Elevation = *MultiByteNum / 7200.0; for (i = 0; i < *Chan; i++) { MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); NMBRecord->Data[i] = *MultiByteNum - 25000.0; } if (*ChanXDump > *Chan) { for (i = 0; i < *ChanXDump- *Chan ; i++) { MultiByteInput(MultiByteMode, MultiByteNum, MultiByteText, InputStream, ErrorStatus); NMBRecord->Scan_coord[i] = *MultiByteNum - 25000.0; } } } /**********************************************************************/ int GetData (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ChanXDump, StartTime, EndTime, DataBuffer, ErrorStatus) int *MultiByteMode, /* the actual Multi Byte Mode */ *ErrorStatus; /* Error Status */ float *MultiByteNum; /* on return the deocded NMB Value */ char *MultiByteText; /* on return the decode NMB String */ FILE *InputStream; /* Input File Stream */ int ChanXDump; float *StartTime; float *EndTime; struct nmbdata DataBuffer[]; { int ArraySize; int GetCounter = 0; int i, j; int ypos; int interactive; struct nmbdata NMBRecord; interactive = isatty(fileno(stdout)); ArraySize = *ErrorStatus; /* play a dirty trick */ *ErrorStatus = 0; if (interactive) { printf("\033[s"); /* save cursor position */ printf("GetData-I: Reading Data"); /* generate Screen Mask */ printf("\033[21;10HZ"); printf("\033[21;70H?"); for (i=11; i<70; i++) printf("\033[21;%dHD\033[23;%dHD", i,i); printf("\033[23;10H@"); printf("\033[23;70HY"); printf("\033[22;10H3"); printf("\033[22;70H3"); } /* read in first record into NMBRecord */ while (!*ErrorStatus) { #ifdef WIN32 GetNMBRecord (MultiByteMode, MultiByteNum, MultiByteText, 0, InputStream, ChanXDump, &NMBRecord, ErrorStatus); #else GetNMBRecord (MultiByteMode, MultiByteNum, MultiByteText, InputStream, ChanXDump, &NMBRecord, ErrorStatus); #endif if (interactive) { ypos = (int)((float)(GetCounter)/(float)(ArraySize) * 58.0); printf("\033[20;30HMemory usage %.f %%", (float)(ypos)*100.0/58.0); printf("\033[22;%dH[", ypos+11); } printf("\033[10;1H%.3f %d", NMBRecord.UT, *ErrorStatus); if ((NMBRecord.UT >= *StartTime) && (NMBRecord.UT <= *EndTime)) DataBuffer[GetCounter++] = NMBRecord; } if (interactive) { for (i=10; i <= 70 ; i++) for (j=20; j <= 23; j++) printf("\033[%d;%dH ", j, i); printf("\033[u"); /*restore saved cursor position */ } fflush(stdout); return(--GetCounter); } void WriteMultiByte(c, Stream) int c; FILE *Stream; { fputc(c, Stream); } void ToMultiByteMode3(ActualMultiByteMode, Stream) int *ActualMultiByteMode; FILE *Stream; { fputc(27, Stream); *ActualMultiByteMode = 3; } void ToMultiByteMode2(ActualMultiByteMode, Stream) int *ActualMultiByteMode; FILE *Stream; { fputc(25, Stream); *ActualMultiByteMode = 2; } void Write3Byte(Value, ActualMultiByteMode, Stream) double Value; int *ActualMultiByteMode; FILE *Stream; { double Temp; int Byte1, Byte2, Byte3; Temp = Value + 2000000.0; if (*ActualMultiByteMode != 3) ToMultiByteMode3(ActualMultiByteMode, Stream); Byte3 = (Temp/50176.0); Temp -= (double)(50176.0)*(double)Byte3; Byte2 = (Temp / (double)(224.0)); Byte1 = (Temp - (double)224.0*(double)(Byte2)); Byte1 += 32; Byte2 += 32; Byte3 += 32; WriteMultiByte(Byte1, Stream); WriteMultiByte(Byte2, Stream); WriteMultiByte(Byte3, Stream); } void Write2Byte(Value, ActualMultiByteMode, Stream) double Value; int *ActualMultiByteMode; FILE *Stream; { int Byte1, Byte2; if ((Value < 0) || (Value > 50175.0)) { if (*ActualMultiByteMode != 3) ToMultiByteMode3(ActualMultiByteMode, Stream); Write3Byte(Value, ActualMultiByteMode, Stream); } else { if (*ActualMultiByteMode != 2) ToMultiByteMode2(ActualMultiByteMode, Stream); Byte2 = Value/224.; Byte1 = Value - 224.*(double)(Byte2); Byte1 += 32; Byte2 += 32; WriteMultiByte(Byte1, Stream); WriteMultiByte(Byte2, Stream); } } void Write2RawData(UT, Azimuth, Elevation, U1, Q1, U2, Q2, ActualMultiByteMode, Stream) float UT, Azimuth, Elevation, U1, Q1, U2, Q2; int *ActualMultiByteMode; FILE *Stream; { double Value; /* Write Time, Azimuth, Elevation in 3 Byte Multi Byte Mode */ ToMultiByteMode3(ActualMultiByteMode, Stream); Value = (double)(30.0) * (double)(UT); Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)(7200.0) * (double)(Azimuth); Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)(7200.0) * (double)(Elevation); Write3Byte(Value, ActualMultiByteMode, Stream); /* write Q, U */ Value = (double)(U1) + 25000.0; Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)(Q1) + 25000.0; Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)(U2) + 25000.0; Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)(Q2) + 25000.0; Write3Byte(Value, ActualMultiByteMode, Stream); fputc(22, Stream); } void WriteRawData(NMBRecordOut, NoOfChannels, ActualMultiByteMode, Stream) struct nmbdata *NMBRecordOut; int *ActualMultiByteMode, NoOfChannels; FILE *Stream; { double Value; int i; /* Write Time, Azimuth, Elevation in 3 Byte Multi Byte Mode */ ToMultiByteMode3(ActualMultiByteMode, Stream); Value = (double)(30.0) * (double)(NMBRecordOut->UT); Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)(7200.0) * (double)(NMBRecordOut->Azimuth); Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)(7200.0) * (double)(NMBRecordOut->Elevation); Write3Byte(Value, ActualMultiByteMode, Stream); for (i = 0; i < 2; i++) { Value = (double)(NMBRecordOut->Scan_coord[i]) + 25000.0; Write2Byte(Value, ActualMultiByteMode, Stream); } /* write data */ for (i = 0; i < NoOfChannels; i++) { Value = (double)(NMBRecordOut->Data[i]) + 25000.0; Write2Byte(Value, ActualMultiByteMode, Stream); /* Write3Byte(Value, ActualMultiByteMode, Stream); */ } fputc(22, Stream); } void WriteSubScan(Number, Epoch, StartTime, ActualMultiByteMode, Stream) int *ActualMultiByteMode, Number; float Epoch, StartTime; FILE *Stream; { double Value; fputc(22, Stream); ToMultiByteMode3(ActualMultiByteMode, Stream); Value = (double)(Number); Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)((int)(Epoch)); Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)(Epoch - (float)((int)(Epoch))) * 10000.0; Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)(30.0) * (double)(StartTime); Write3Byte(Value, ActualMultiByteMode, Stream); } void DataFileClose(Stream) FILE *Stream; { fputc(23, Stream); fclose(Stream); } void ChangeHeader(Header) struct head *Header; { int i; /* change Header according new Channels and Dumps */ for (i = 0; i < NPREHEADER; i++) { if (strcmp(Header->PreHeader[i], ">CHANNELS 3") == 0) sprintf(Header->PreHeader[i],">CHANNELS 4"); if (strcmp(Header->PreHeader[i], ">DUMPS 16") == 0) sprintf(Header->PreHeader[i],">DUMPS 1"); } } void ChangeHeaderOneDump(Header) struct head *Header; { int i; /* change Header according new Channels and Dumps */ for (i = 0; i < NPREHEADER; i++) if (strcmp(Header->PreHeader[i], ">DUMPS 4") == 0) sprintf(Header->PreHeader[i],">DUMPS 1"); } void WriteHeaderInformation(Header, Stream) struct head *Header; FILE *Stream; { int i; WriteMultiByte(21, Stream); WriteMultiByte(65, Stream); for (i = 0; i < NPREHEADER; i++) { WriteMultiByte(28, Stream); fprintf(Stream, "%s\n",Header->PreHeader[i]); WriteMultiByte(22, Stream); } WriteMultiByte(29, Stream); fprintf(Stream,"-99999\n"); WriteMultiByte(28, Stream); fprintf(Stream, " %04d %s\n", Header->ScanNumber, Header->SourceName); WriteMultiByte(22, Stream); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Frequency); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->Gain); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->Magnet); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->Channels); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->Phases); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Lambda.S); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Lambda.O); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Lambda.V); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->Lambda.Star); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Beta.S); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Beta.O); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Beta.V); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Azimuth.S); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Azimuth.O); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Azimuth.V); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->Azimuth.Star); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Elevation.S); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Elevation.O); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Elevation.V); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->SFC.X); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->SFC.Y); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->SFC.Z); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->SPH.X); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->SPH.Y); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->SPH.Z); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->sint); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->sbas); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Epoch); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->DAZM); for (i = 0; i < 4; i++) { WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->SRP[i]); } WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->SDC); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Pressure); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Temperature); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Humidity); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->Refraction); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->NULA); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->NULE); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->ColStar); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->Date.Year); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->Date.Month); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->Date.Day); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->WobblingDevice); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->WobblingAmpli); WriteMultiByte(29, Stream); fprintf(Stream,"%f\n",Header->WobblingPeriod); WriteMultiByte(29, Stream); fprintf(Stream,"%d\n",Header->WobblingMode); } void WriteSubScanInformation(top, ActualMultiByteMode, Stream) struct subscans *top; int *ActualMultiByteMode; FILE *Stream; { double Value; while(top) { WriteMultiByte(22, Stream); ToMultiByteMode3(ActualMultiByteMode, Stream); Value = (double)top->Number; Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)((int)(top->Epoch)); Write3Byte(Value, ActualMultiByteMode, Stream); Value -= (double)top->Epoch; Value *= -10000.0; Write3Byte(Value, ActualMultiByteMode, Stream); Value = (double)top->Time * (double)30.0; Write3Byte(Value, ActualMultiByteMode, Stream); top = top->next; } WriteMultiByte(29, Stream); fprintf(Stream,"-88888\n"); } void WriteASCIIHeader(Header, Stream) struct head *Header; FILE *Stream; { char help[80]; int i, j; for (i = 0; i < NPREHEADER; i++) { for (j=0;j<80;j++) help[j] = ' '; sprintf(help, "%s\n", Header->PreHeader[i]); /** strnset(help, '/', 1); **/ strncpy(help,"/", 1); j = 2; while (help[j] != ' ') {help[j] = tolower(help[j]); j++;} fprintf(Stream, help); } fprintf(Stream,"/ScanNumber %d\n", Header->ScanNumber); fprintf(Stream,"/SourceName %s\n", Header->SourceName); fprintf(Stream,"/Frequency %f\n", Header->Frequency); fprintf(Stream,"/Gain %d\n", Header->Gain); if (Header->Magnet == 0) fprintf(Stream,"/Paddle out\n"); else fprintf(Stream,"/Paddle in\n"); fprintf(Stream,"/Phases %d\n",Header->Phases); fprintf(Stream,"/SLAM %f\n",Header->Lambda.S); fprintf(Stream,"/OLAM %f\n",Header->Lambda.O); fprintf(Stream,"/VLAM %f\n",Header->Lambda.V); fprintf(Stream,"/LAMSTAR %d\n",Header->Lambda.Star); fprintf(Stream,"/SBET %f\n",Header->Beta.S); fprintf(Stream,"/OBET %f\n",Header->Beta.O); fprintf(Stream,"/VBET %f\n",Header->Beta.V); fprintf(Stream,"/SAZM %f\n",Header->Azimuth.S); fprintf(Stream,"/OAZM %f\n",Header->Azimuth.O); fprintf(Stream,"/VAZM %f\n",Header->Azimuth.V); fprintf(Stream,"/AZMSTAR %d\n",Header->Azimuth.Star); fprintf(Stream,"/SELV %f\n",Header->Elevation.S); fprintf(Stream,"/OELV %f\n",Header->Elevation.O); fprintf(Stream,"/VELV %f\n",Header->Elevation.V); fprintf(Stream,"/SFCX %f\n",Header->SFC.X); fprintf(Stream,"/SFCY %f\n",Header->SFC.Y); fprintf(Stream,"/SFCZ %f\n",Header->SFC.Z); fprintf(Stream,"/SPHX %f\n",Header->SPH.X); fprintf(Stream,"/SPHY %f\n",Header->SPH.Y); fprintf(Stream,"/SPHZ %f\n",Header->SPH.Z); fprintf(Stream,"/SINT %f\n",Header->sint); fprintf(Stream,"/SBAS %d\n",Header->sbas); fprintf(Stream,"/EPOCH %f\n",Header->Epoch); fprintf(Stream,"/DAZM %f\n",Header->DAZM); fprintf(Stream,"/SRP1 %d\n",Header->SRP[0]); fprintf(Stream,"/SRP2 %d\n",Header->SRP[1]); fprintf(Stream,"/SR1OPTFLAG %d\n",Header->SRP[2]); fprintf(Stream,"/SR2OPTFLAG %d\n",Header->SRP[3]); fprintf(Stream,"/SDC %d\n",Header->SDC); fprintf(Stream,"/PRESSURE %f\n",Header->Pressure); fprintf(Stream,"/TEMPERATURE %f\n",Header->Temperature); fprintf(Stream,"/HUMIDITY %f\n",Header->Humidity); fprintf(Stream,"/REFRACTION %f\n",Header->Refraction); fprintf(Stream,"/NULA %f\n",Header->NULA); fprintf(Stream,"/NULE %f\n",Header->NULE); fprintf(Stream,"/COLSTAR %f\n",Header->ColStar); fprintf(Stream,"/WobblingDevice %d\n",Header->WobblingDevice); fprintf(Stream,"/WobblingAmpli %f\n",Header->WobblingAmpli); fprintf(Stream,"/WobblingPeriod %f\n",Header->WobblingPeriod); /** fprintf(Stream,"/WobblingMode %d\n",Header->WobblingMode); **/ fprintf(Stream,"/EndOfHeaderData\n"); } void WriteASCIISubScan(top, Stream) struct subscans *top; FILE *Stream; { fprintf(Stream,"/SUBSCANFORMAT (I3,1X,F12.4,3X,F12.3)\n"); while(top) { fprintf(Stream, "%3d %12.4f %12.3f\n", top->Number, top->Epoch, top->Time); top = top->next; } fprintf(Stream,"/EndOfSubScanData\n"); }