int
main(int argc, char *argv[])
{
FILE *p;
FILE *q;
if (argc != 3)
{
fprintf(stderr, "Use: %s src dst\n", PROGRAM_NAME);
exit(EXIT_FAILURE);
}
p = fopen(argv[1], "r");
if (!p)
{
fprintf(stderr, "%s : Couldn't read file '%s'\n", PROGRAM_NAME, argv[1]);
exit(EXIT_FAILURE);
}
q = fopen(argv[2], "w");
if (!q)
{
fprintf(stderr, "%s : Couldn't write file '%s'\n", PROGRAM_NAME, argv[2]);
exit(EXIT_FAILURE);
}
while(!feof(p))
{
float ent;
if(fread(&ent, sizeof(ent), 1, p) != 1)
break;
//printf("%g (era %g)\n", FloatSwap(ent), ent);
ent = FloatSwap(ent);
if (fwrite(&ent, sizeof(ent), 1, q) != 1)
fprintf(stderr, "Hey! Didn't write the float!\n");
}
fclose(p);
fclose(q);
return EXIT_SUCCESS;
}
void ahrs_chimu_update_gps(void)
{
// Send SW Centripetal Corrections
uint8_t centripedal[19] = {0xae, 0xae, 0x0d, 0xaa, 0x0b, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc2 };
float gps_speed = 0;
if (gps.fix == GPS_FIX_3D) {
gps_speed = gps.speed_3d / 100.;
}
gps_speed = FloatSwap(gps_speed);
memmove(¢ripedal[6], &gps_speed, 4);
// Fill X-speed
CHIMU_Checksum(centripedal, 19);
InsSend(centripedal, 19);
// Downlink Send
}
void ahrs_chimu_update_gps(uint8_t gps_fix __attribute__((unused)), uint16_t gps_speed_3d)
{
// Send SW Centripetal Corrections
uint8_t centripedal[19] = {0xae, 0xae, 0x0d, 0xaa, 0x0b, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc2 };
float gps_speed = 0;
if (GpsFixValid()) {
gps_speed = gps_speed_3d / 100.;
}
gps_speed = FloatSwap(gps_speed);
memmove(¢ripedal[6], &gps_speed, 4);
// Fill X-speed
CHIMU_Checksum(centripedal, 19);
InsSend(centripedal, 19);
// Downlink Send
}
// ====================================================================
// MAIN PROGRAM
// ====================================================================
int main( int argc, char *argv[] )
{
char *filename;
FILE *fp;
uint j;
uint offset_up, offset_down;
flip_image_flag = false;
swap_flag = false;
if ( argc == 5 )
{
filename = (char *)argv[1];
width = (uint)atoi(argv[2]);
height = (uint)atoi(argv[3]);
image_type = (uint)atoi(argv[4]);
}
else if ( argc == 6 )
{
filename = (char *)argv[1];
width = (uint)atoi(argv[2]);
height = (uint)atoi(argv[3]);
image_type = (uint)atoi(argv[4]);
if ( atoi(argv[5]) == 1 ) // Swap Endian
swap_flag = true;
}
else if ( argc == 7 )
{
filename = (char *)argv[1];
width = (uint)atoi(argv[2]);
height = (uint)atoi(argv[3]);
image_type = (uint)atoi(argv[4]);
if ( atoi(argv[5]) == 1 ) // Swap Endian
swap_flag = true;
if ( atoi(argv[6]) == 1 ) // Flip image
flip_image_flag = true;
}
else {
printf("\n Usage: %s Filename Width Height Image_Type [Swap_Endian (0 or 1) Flip_Image (0 or 1)]\n\n", argv[0]);
printf(" Image Type: 0 ( PIXEL_32BIT ) \n");
printf(" 1 ( PIXEL_64BIT ) \n");
printf(" 2 ( PIXEL_128BIT ) \n");
printf(" 3 ( PIXEL_160BIT ) \n");
return ( EXIT_FAILURE );
}
// ====================================================================
if ( ( image_type < 0 ) || ( image_type > 3 ) ){
printf("\n Invalid Image Type \n");
printf(" Image Type: 0 ( PIXEL_32BIT ) \n");
printf(" 1 ( PIXEL_64BIT ) \n");
printf(" 2 ( PIXEL_128BIT ) \n");
printf(" 3 ( PIXEL_160BIT ) \n");
return ( EXIT_FAILURE );
}
// ====================================================================
if ( ( fp = fopen( filename, "rb")) == NULL ) {
printf("<<< ERROR >>> Cannot open file: %s \n", filename );
return 1;
}
image_resolution = width * height;
// ====================================================================
// PIXEL_32BIT ; PIXEL_56BIT ; PIXEL_64BIT ; PIXEL_88BIT
if (( image_type == 0 ) || ( image_type == 1 ))
{
if ( image_type == 0 ) { // PIXEL_32BIT
input_image_size = image_resolution * PIXEL_32BIT ;
}
else if ( image_type == 1 ) { // PIXEL_64BIT
input_image_size = image_resolution * PIXEL_64BIT ;
}
display_image_size = image_resolution * PIXEL_32BIT ;
input_byte_image = (GLubyte *)malloc ( input_image_size * sizeof(GLubyte) );
memset( input_byte_image, 0, input_image_size * sizeof(GLubyte) );
display_byte_image = (GLubyte *)malloc ( display_image_size * sizeof(GLubyte) );
memset( display_byte_image, 0, display_image_size * sizeof(GLubyte) );
flip_byte_image = (GLubyte *)malloc ( display_image_size * sizeof(GLubyte) );
memset( flip_byte_image, 0, display_image_size * sizeof(GLubyte) );
if ( fread ( input_byte_image, input_image_size, 1, fp ) != 1 ) {
perror("<<< ERROR >>> Cannot read image \n" );
exit( EXIT_FAILURE );
}
if ( image_type == 0 ) { // PIXEL_32BIT
if ( flip_image_flag == true )
{
// =======================================
// FLIP IMAGE
// =======================================
for ( j = 0; j < height; j++ ) {
for ( i = 0; i < width; i++ ) {
offset_up = ( j * width + i ) * 4; // 4 elements
offset_down = (( height - 1 - j ) * width + i ) * 4; // 4 elements
display_byte_image[ offset_up ] = input_byte_image[ offset_down ]; // R
display_byte_image[ offset_up + 1 ] = input_byte_image[ offset_down + 1 ]; // G
display_byte_image[ offset_up + 2 ] = input_byte_image[ offset_down + 2 ]; // B
display_byte_image[ offset_up + 3 ] = input_byte_image[ offset_down + 3 ]; // A
}
}
}
else {
// =======================================
// NORMAL IMAGE
// =======================================
for ( i = 0; i < ( image_resolution * 4 ); i += 4 ) {
display_byte_image[ i ] = (BYTE)input_byte_image[ i ]; // R
display_byte_image[ i + 1 ] = (BYTE)input_byte_image[ i + 1 ]; // G
display_byte_image[ i + 2 ] = (BYTE)input_byte_image[ i + 2 ]; // B
display_byte_image[ i + 3 ] = (BYTE)input_byte_image[ i + 3 ]; // A
}
}
}
else if ( image_type == 1 ) { // PIXEL_64BIT
// =======================================
// Image Tye: RGBAZ64
// =======================================
j = 0;
for ( i = 0; i < ( image_resolution * 8 ); i += 8 ) {
display_byte_image[ j ] = (BYTE)input_byte_image[ i ]; // R
display_byte_image[ j + 1 ] = (BYTE)input_byte_image[ i + 1 ]; // G
display_byte_image[ j + 2 ] = (BYTE)input_byte_image[ i + 2 ]; // B
display_byte_image[ j + 3 ] = (BYTE)input_byte_image[ i + 3 ]; // A
j += 4;
}
if ( flip_image_flag == true )
{
// =======================================
// FLIP IMAGE
// =======================================
memcpy ( input_byte_image, display_byte_image, display_image_size );
for ( j = 0; j < height; j++ ) {
for ( i = 0; i < width; i++ ) {
offset_up = ( j * width + i ) * 4; // 4 elements
offset_down = (( height - 1 - j ) * width + i ) * 4; // 4 elements
display_byte_image[ offset_up ] = input_byte_image[ offset_down ]; // R
display_byte_image[ offset_up + 1 ] = input_byte_image[ offset_down + 1 ]; // G
display_byte_image[ offset_up + 2 ] = input_byte_image[ offset_down + 2 ]; // B
display_byte_image[ offset_up + 3 ] = input_byte_image[ offset_down + 3 ]; // A
}
}
}
}
// ====================================================================
glutInit ( &argc, argv );
glutInitWindowPosition ( 0, 0 );
glutInitWindowSize ( width, height );
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glutInitDisplayMode ( GLUT_SINGLE | GLUT_RGBA | GLUT_ALPHA);
glutCreateWindow ( "RGBA Image Viewer" );
glutIdleFunc ( NULL );
glutReshapeFunc ( Reshape_Window ); // Reshape call back
glutKeyboardFunc ( Keyboard_Press ); // Keyboard pressing call back
glutMouseFunc ( Mouse_Click ); // Mouse click call back
glutDisplayFunc ( Display_BYTE );
glutMainLoop();
// ====================================================================
}
else if (( image_type == 2 ) || ( image_type == 3 )) // PIXEL_128BIT of PIXEL_160BIT
{
// ====================================================================
if ( image_type == 2 ) { // PIXEL_128BIT
input_image_size = image_resolution * PIXEL_128BIT ;
}
else { // PIXEL_160BIT
input_image_size = image_resolution * PIXEL_160BIT ;
}
display_image_size = image_resolution * PIXEL_128BIT ;
input_float_image = (GLfloat *)malloc ( input_image_size * sizeof(GLfloat) );
memset( input_float_image, 0, input_image_size * sizeof(GLfloat) );
display_float_image = (GLfloat *)malloc ( display_image_size * sizeof(GLfloat) );
memset( display_float_image, 0, display_image_size * sizeof(GLfloat) );
flip_float_image = (GLfloat *)malloc ( display_image_size * sizeof(GLfloat) );
memset( flip_float_image, 0, display_image_size * sizeof(GLfloat) );
fread ( input_float_image, input_image_size, 1, fp );
if ( image_type == 2 ) { // PIXEL_128BIT
// =======================================
// Image Tye: RGBA128
// =======================================
if ( swap_flag == true )
{
// =======================================
// BIG <-> LITTLE ENDIAN
// =======================================
if ( flip_image_flag == true )
{
// =======================================
// FLIP IMAGE
// =======================================
for ( j = 0; j < height; j++ ) {
for ( i = 0; i < width; i++ ) {
offset_up = ( j * width + i ) * 4; // 4 Eelements
offset_down = (( height - 1 - j ) * width + i ) * 4; // 4 Eelements
float_val1 = input_float_image[ offset_down ];
float_val2 = input_float_image[ offset_down + 1 ];
float_val3 = input_float_image[ offset_down + 2 ];
float_val4 = input_float_image[ offset_down + 3 ];
float_val1 = FloatSwap( float_val1 );
float_val2 = FloatSwap( float_val2 );
float_val3 = FloatSwap( float_val3 );
float_val4 = FloatSwap( float_val4 );
display_float_image[ offset_up ] = float_val1;
display_float_image[ offset_up + 1 ] = float_val2;
display_float_image[ offset_up + 2 ] = float_val3;
display_float_image[ offset_up + 3 ] = float_val4;
}
}
}
else {
// =======================================
// NORMAL IMAGE
// =======================================
for ( i = 0; i < ( image_resolution * 4 ); i += 4 )
{
float_val1 = (float)input_float_image[ i ];
float_val2 = (float)input_float_image[ i + 1 ];
float_val3 = (float)input_float_image[ i + 2 ];
float_val4 = (float)input_float_image[ i + 3 ];
float_val1 = FloatSwap( float_val1 );
float_val2 = FloatSwap( float_val2 );
float_val3 = FloatSwap( float_val3 );
float_val4 = FloatSwap( float_val4 );
display_float_image[ i ] = (float)float_val1;
display_float_image[ i + 1 ] = (float)float_val2;
display_float_image[ i + 2 ] = (float)float_val3;
display_float_image[ i + 3 ] = (float)float_val4;
}
}
}
else // swap_flag == false
{
if ( flip_image_flag == true )
{
// =======================================
// FLIP IMAGE
// =======================================
for ( j = 0; j < height; j++ ) {
for ( i = 0; i < width; i++ ) {
offset_up = ( j * width + i ) * 4; // 4 Eelements
offset_down = (( height - 1 - j ) * width + i ) * 4; // 4 Eelements
display_float_image[ offset_up ] = input_float_image[ offset_down ];
display_float_image[ offset_up + 1 ] = input_float_image[ offset_down + 1 ];
display_float_image[ offset_up + 2 ] = input_float_image[ offset_down + 2 ];
display_float_image[ offset_up + 3 ] = input_float_image[ offset_down + 3 ];
}
}
}
else {
printf("PIXEL: R(%f) G(%f) B(%f) A(%f) \n", \
input_float_image[0], input_float_image[1], input_float_image[2], input_float_image[3] );
// =======================================
// NORMAL IMAGE
// =======================================
for ( i = 0; i < ( image_resolution * 4 ); i += 4 ) {
display_float_image[ i ] = input_float_image[ i ];
display_float_image[ i + 1 ] = input_float_image[ i + 1 ];
display_float_image[ i + 2 ] = input_float_image[ i + 2 ];
display_float_image[ i + 3 ] = input_float_image[ i + 3 ];
}
}
}
}
else if ( image_type == 3 ) { // PIXEL_160BIT
input_float_image_ptr = (float *)input_float_image;
display_float_image_ptr = (float *)display_float_image;
// =======================================
// Image Tye: RGBAZ160
// =======================================
if ( swap_flag == true )
{
// =======================================
// BIG <-> LITTLE ENDIAN
// =======================================
j = 0;
for ( i = 0; i < input_image_size; i += 5 ) {
float_val1 = (float)input_float_image_ptr[ i ];
float_val2 = (float)input_float_image_ptr[ i + 1 ];
float_val3 = (float)input_float_image_ptr[ i + 2 ];
float_val4 = (float)input_float_image_ptr[ i + 3 ];
float_val1 = FloatSwap( float_val1 );
float_val2 = FloatSwap( float_val2 );
float_val3 = FloatSwap( float_val3 );
float_val4 = FloatSwap( float_val4 );
// display_float_image_ptr: RGBA 4 elements
// input_float_image_ptr : RGBAZ 5 elements
display_float_image_ptr[ j ] = (float)float_val1;
display_float_image_ptr[ j + 1 ] = (float)float_val2;
display_float_image_ptr[ j + 2 ] = (float)float_val3;
display_float_image_ptr[ j + 3 ] = (float)float_val4;
j += 4;
}
}
else
{
// =======================================
// Image Tye: RGBAZ160
// =======================================
j = 0;
for ( i = 0; i < input_image_size; i += 5 ) {
// display_float_image_ptr: RGBA 4 elements
// input_float_image_ptr : RGBAZ 5 elements
display_float_image_ptr[ j ] = (float)input_float_image_ptr[ i ];
display_float_image_ptr[ j + 1 ] = (float)input_float_image_ptr[ i + 1 ];
display_float_image_ptr[ j + 2 ] = (float)input_float_image_ptr[ i + 2 ];
display_float_image_ptr[ j + 3 ] = (float)input_float_image_ptr[ i + 3 ];
j += 4;
}
}
// =======================================
// FLIP IMAGE
// =======================================
if ( flip_image_flag == true )
{
memcpy ( input_float_image, display_float_image, display_image_size );
for ( j = 0; j < height; j++ ) {
for ( i = 0; i < width; i++ ) {
offset_up = ( j * width + i ) * 4; // 4 Eelements
offset_down = (( height - 1 - j ) * width + i ) * 4; // 4 Eelements
display_float_image[ offset_up ] = input_float_image[ offset_down ];
display_float_image[ offset_up + 1 ] = input_float_image[ offset_down + 1 ];
display_float_image[ offset_up + 2 ] = input_float_image[ offset_down + 2 ];
display_float_image[ offset_up + 3 ] = input_float_image[ offset_down + 3 ];
}
}
}
}
// ====================================================================
glutInit ( &argc, argv );
glutInitWindowPosition ( 0, 0 );
glutInitWindowSize ( width, height );
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glutInitDisplayMode ( GLUT_SINGLE | GLUT_RGBA | GLUT_ALPHA);
glutCreateWindow ( "RGBA FLOAT Image Viewer" );
glutIdleFunc ( NULL );
glutReshapeFunc ( Reshape_Window ); // Reshape call back
glutKeyboardFunc ( Keyboard_Press ); // Keyboard pressing call back
glutMouseFunc ( Mouse_Click ); // Mouse click call back
glutDisplayFunc ( Display_FLOAT );
glutMainLoop();
}
// ===========================================================
if ( input_byte_image )
free( input_byte_image );
if ( input_float_image )
free( input_float_image );
if ( display_byte_image )
free( display_byte_image );
if ( display_float_image )
free( display_float_image );
fclose(fp);
return ( 0 );
}
inline float Sys_LittleFloat (const float l)
{
return FloatSwap(&l);
}
main (int argc, char *argv[]) {
float PARMOD[10];
PARMOD[0]= 0.0;
PARMOD[1]= 0.0;
PARMOD[2]= 0.0;
PARMOD[3]=0.0;
PARMOD[4]=0.0;
PARMOD[5]=0.0;
PARMOD[6]=0.0;
int iopt;
int i,j,k;
float kp = 6.0;
float ps = 0.0;
float bxout,byout,bzout; // THESE NEED TO BE STORED IN MEMORY NOW
// TIMESTEP LOOP STARTS HERE
//int m;
//for(m=0;m<=72;m++){
// NEED TO CALCULATE Kp HERE
// NEED TO COMPARE Kp RESULT TO iopt AND SET
if(kp < 0.5){
iopt = 1;
}
else if(kp > 0.5 && kp < 1.5){
iopt = 2;
}
else if(kp > 1.5 && kp < 2.5){
iopt = 3;
}
else if(kp > 2.5 && kp < 3.5){
iopt = 4;
}
else if(kp > 3.5 && kp < 4.5){
iopt = 5;
}
else if(kp > 4.5 && kp < 5.5){
iopt = 6;
}
else if(kp > 5.5){
iopt = 7;
}
// CREATE GRID AND STORE IN MEMORY
int npoinx = 345, npoiny = 187, npoinz = 187;
int xmin=-222, ymin=-47, zmin=ymin;
int xmax=30, ymax=47, zmax=ymax;
//float *xcord = new float[npoinx];
float *xcord = malloc(npoinx * sizeof(float));
xcord[0] = xmin;
// X COORDINATES
i = 0;
while (xcord[i] < xmax){
i++;
if(xcord[i-1] < -30. || xcord[i-1] >= 30.){ xcord[i] = xcord[i-1]+1.; }
else if(xcord[i-1] < -8. || xcord[i-1] >= 8.){ xcord[i] = xcord[i-1]+0.5; }
else if(xcord[i-1] <= 0. || xcord[i-1] >= 0.){ xcord[i] = xcord[i-1]+0.25; }
}
i = 0;
//float *ycord = new float[npoiny];
float *ycord = malloc(npoiny * sizeof(float));
ycord[0] = ymin;
// Y COORDINATES
while (ycord[i] < ymax){
i++;
if(ycord[i-1] < -30. || ycord[i-1] >= 30.){ ycord[i] = ycord[i-1]+1.; }
else if(ycord[i-1] < -8. || ycord[i-1] >= 8.){ ycord[i] = ycord[i-1]+0.5; }
else if(ycord[i-1] <= 0. || ycord[i-1] >= 0.){ ycord[i] = ycord[i-1]+0.25; }
}
i = 0;
//float *zcord = new float[npoinz];
float *zcord = malloc(npoinz * sizeof(float));
zcord[0] = zmin;
// Z COORDINATES
while (zcord[i] < zmax){
i++;
if(zcord[i-1] < -30. || zcord[i-1] >= 30.){ zcord[i] = zcord[i-1]+1.; }
else if(zcord[i-1] < -8. || zcord[i-1] >= 8.){ zcord[i] = zcord[i-1]+0.5; }
else if(zcord[i-1] <= 0. || zcord[i-1] >= 0.){ zcord[i] = zcord[i-1]+0.25; }
}
// GRID LOOP STARTS HERE
int l=0;
float *bx = malloc(npoinx*npoiny*npoinz * sizeof(float));
float *by = malloc(npoiny*npoiny*npoinz * sizeof(float));
float *bz = malloc(npoinz*npoiny*npoinz * sizeof(float));
for ( k = 0; k < npoinz; k++){
for ( j = 0; j < npoiny; j++){
for ( i = 0; i < npoinx; i++){
// EACH NEW GRID POINT PASS THROUGH THIS FUNCTION
//t89c_(&iopt,PARMOD,&ps,&xcord[i],&ycord[j],&zcord[k],&bxout,&byout,&bzout);
t89c_(&iopt,PARMOD,&ps,&xcord[i],&ycord[j],&zcord[k],&bxout,&byout,&bzout);
bx[l] = bxout;
by[l] = byout;
bz[l] = bzout;
//printf("bx=%f,by=%f,bz=%f\n",bxout,byout,bzout);
//return 0;
l++;
}
}
}
//}
// WRITE VTK FILE
// BINARY VTK FILE
float val, val1, val2;
FILE *myfile;
myfile = fopen("/home/bcurtis/Tsyganenko/output/T89/Result0.vtk","w");
fprintf(myfile, "# vtk DataFile Version 3.0\n");
fprintf(myfile, "Brian's Data\nBINARY\n");
fprintf(myfile, "DATASET RECTILINEAR_GRID\n");
fprintf(myfile, "DIMENSIONS %d %d %d\n", npoinx, npoiny, npoinz);
fprintf(myfile, "X_COORDINATES %d float\n", npoinx);
for (i=0; i<npoinx; i++){
val = FloatSwap(xcord[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nY_COORDINATES %d float\n", npoiny);
for (i=0; i<npoiny; i++){
val = FloatSwap(ycord[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nZ_COORDINATES %d float\n", npoinz);
for (i=0; i<npoinz; i++){
val = FloatSwap(zcord[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nPOINT_DATA %d\n", npoinx*npoiny*npoinz);
fprintf(myfile, "\nVECTORS B FLOAT\n");
for (i=0; i<npoinx*npoiny*npoinz; i++){
val = FloatSwap(bx[i]);
val1 = FloatSwap(by[i]);
val2 = FloatSwap(bz[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
fwrite((void *)&val1, sizeof(float), 1, myfile);
fwrite((void *)&val2, sizeof(float), 1, myfile);
}
fclose(myfile);
printf("VTK Write Complete\n");
/*FILE *bxfile;
FILE *byfile;
FILE *bzfile;
bxfile = fopen("/home/bcurtis/Tsyganenko/output/T89/Bx.dat","w");
byfile = fopen("/home/bcurtis/Tsyganenko/output/T89/By.dat","w");
bzfile = fopen("/home/bcurtis/Tsyganenko/output/T89/Bz.dat","w");
fprintf(bxfile, "X\tY\tZ\tBx\n");
fprintf(byfile, "X\tY\tZ\tBy\n");
fprintf(bzfile, "X\tY\tZ\tBz\n");
l=0;
for ( k = 0; k < npoinz; k++){
for ( j = 0; j < npoiny; j++){
for ( i = 0; i < npoinx; i++){
fprintf(bxfile, "%f\t%f\t%f\t%f\n", xcord[i], ycord[j], zcord[k], bx[l]);
fprintf(byfile, "%f\t%f\t%f\t%f\n", xcord[i], ycord[j], zcord[k], by[l]);
fprintf(bzfile, "%f\t%f\t%f\t%f\n", xcord[i], ycord[j], zcord[k], bz[l]);
l++;
}
}
}
fclose(bxfile);
fclose(byfile);
fclose(bzfile);
printf(".dat File Write Complete\n");
*/
//free(xcord); free(bx);
//free(ycord); free(by);
//free(zcord); free(bz);
return 0;
}
int main (int argc, char * argv[]){
const char* dirname;
if (argc > 1) {
dirname = argv[1];
} else {
dirname = "../data/";
}
ccmc::Kameleon kameleon1, kameleon2;
std::string filename1, filename2;
std::string variable;
std::vector<int> myvars;
bool firstrun=true, CALCDIFF=false;
int i,j,k,m;
int npoinx = 345;
int npoiny = 187;
int npoinz = 187;
float *xcord = new float[npoinx];
float *ycord = new float[npoiny];
float *zcord = new float[npoinz];
grid(xcord,ycord,zcord);
std::cout << "Reading " << dirname << std::endl;
std::vector<std::string> chooserun;
rundirs(&chooserun, dirname);
DIR *d;
struct dirent *dir;
int dset1 [24] = {0,0,0,1,1,2,4,4,4,5,5,6,8,8,8,9,9,10,12,12,12,13,13,14};
int dset2 [24] = {1,2,3,2,3,3,5,6,7,6,7,7,9,10,11,10,11,11,13,14,15,14,15,15};
int runi;
for ( runi = 0; runi < 24; runi++){
if(dset2[runi]==3 || dset2[runi]==7 || dset2[runi]==11 || dset2[runi]==15){
std::cout << "Skipping Run " << runi << std::endl;
continue;
}
std::cout << "Dataset 1" << ": " << chooserun[dset1[runi]] << std::endl;
std::cout << "Dataset 2" << ": " << chooserun[dset2[runi]] << std::endl;
std::vector<std::string> run1ls;
std::string dirstring;
dirstring = dirname;
dirstring.append(chooserun[dset1[runi]]);
dirstring.append("/GM_CDF");
d = opendir(dirstring.c_str());
if (d) {
while ((dir = readdir(d)) != NULL) {
if(strcmp(dir->d_name,"..") && strcmp(dir->d_name,".")){
//i++;
run1ls.push_back(dir->d_name);
}
}
}
// SORT THE STRING SO FILENAMES ARE IN ORDER
std::sort(run1ls.begin(), run1ls.end());
std::vector<std::string> run2ls;
std::string dirstring3;
std::cout << "SETTING DIRSTRING3" << std::endl;
dirstring3 = dirname;
dirstring3.append(chooserun[dset2[runi]]);
dirstring3.append("/GM_CDF");
d = opendir(dirstring3.c_str());
if (d) {
while ((dir = readdir(d)) != NULL) {
if(strcmp(dir->d_name,"..") && strcmp(dir->d_name,".")){
//i++;
run2ls.push_back(dir->d_name);
}
}
}
// SORT THE STRING SO FILENAMES ARE IN ORDER
std::sort(run2ls.begin(), run2ls.end());
//return 0;
int loopnum;
for(loopnum=0; loopnum<run1ls.size(); loopnum++ ){
filename1 = dirstring;
filename1.append("/");
filename1.append(run1ls[loopnum]);
std::cout << filename1 << std::endl;
filename2 = dirstring3;
filename2.append("/");
filename2.append(run2ls[loopnum]);
std::cout << filename2 << std::endl;
long status = kameleon1.open(filename1);
std::cout << "Opened file: " << filename1 << " with status: " << status << std::endl;
std::cout << "FileReader::OK = " << ccmc::FileReader::OK << std::endl;
//int numvars = kameleon1.getNumberOfVariables();
//for(int bb=0; bb<numvars; bb++){
// std::cout << "K1 Variable " << bb << "= " << kameleon1.getVariableName(bb) << std::endl;
//}
if(kameleon1.doesVariableExist("bz")){kameleon1.loadVariable("bz");}else{return 1;}
if(kameleon1.doesVariableExist("jx")){kameleon1.loadVariable("jx");}else{return 1;}
if(kameleon1.doesVariableExist("rho")){kameleon1.loadVariable("rho");}else{return 1;}
if(kameleon1.doesVariableExist("ux")){kameleon1.loadVariable("ux");}else{return 1;}
long status2 = kameleon2.open(filename2);
std::cout << "Opened file: " << filename2 << " with status: " << status2 << std::endl;
std::cout << "FileReader::OK = " << ccmc::FileReader::OK << std::endl;
// TEMP LIST ALL VARIABLE NAMES
//numvars = kameleon2.getNumberOfVariables();
//for(int ab=0; ab<numvars; ab++){
// std::cout << "K2 Variable " << ab << "= " << kameleon2.getVariableName(ab) << std::endl;
//}
if(kameleon2.doesVariableExist("bz")){kameleon2.loadVariable("bz");}else{return 1;}
if(kameleon2.doesVariableExist("jx")){kameleon2.loadVariable("jx");}else{return 1;}
if(kameleon2.doesVariableExist("rho")){kameleon2.loadVariable("rho");}else{return 1;}
if(kameleon2.doesVariableExist("ux")){kameleon2.loadVariable("ux");}else{return 1;}
// INTERPOLATION #1
ccmc::Interpolator * interpolator = kameleon1.createNewInterpolator();
ccmc::Interpolator * interpolator2 = kameleon2.createNewInterpolator();
boost::numeric::ublas::matrix<float> value(4,npoinx*npoiny*npoinz), \
value2(4,npoinx*npoiny*npoinz), \
diff(4,npoinx*npoiny*npoinz);
std::cout << "Starting Interpolations and Diff" << std::endl;
int l=0;
for ( k = 0; k < npoinz; k++){
for ( j = 0; j < npoiny; j++){
for ( i = 0; i < npoinx; i++){
value(0,l) = interpolator->interpolate("bz", xcord[i], ycord[j], zcord[k]);
value(1,l) = interpolator->interpolate("jx", xcord[i], ycord[j], zcord[k]);
value(2,l) = interpolator->interpolate("rho", xcord[i], ycord[j], zcord[k]);
value(3,l) = interpolator->interpolate("ux", xcord[i], ycord[j], zcord[k]);
value2(0,l) = interpolator2->interpolate("bz", xcord[i], ycord[j], zcord[k]);
value2(1,l) = interpolator2->interpolate("jx", xcord[i], ycord[j], zcord[k]);
value2(2,l) = interpolator2->interpolate("rho", xcord[i], ycord[j], zcord[k]);
value2(3,l) = interpolator2->interpolate("ux", xcord[i], ycord[j], zcord[k]);
diff(0,l) = (( value(0,l)-value2(0,l) ) / ( (value(0,l)+value2(0,l)) / 2.0 ))*100.0;
diff(1,l) = (( value(1,l)-value2(1,l) ) / ( (value(1,l)+value2(1,l)) / 2.0 ))*100.0;
diff(2,l) = (( value(2,l)-value2(2,l) ) / ( (value(2,l)+value2(2,l)) / 2.0 ))*100.0;
diff(3,l) = (( value(3,l)-value2(3,l) ) / ( (value(3,l)+value2(3,l)) / 2.0 ))*100.0;
l++;
}
}
}
std::cout << "Interpolations and Diff Complete" << std::endl;
kameleon1.unloadVariable("bz");
kameleon1.unloadVariable("jx");
kameleon1.unloadVariable("rho");
kameleon1.unloadVariable("ux");
kameleon2.unloadVariable("bz");
kameleon2.unloadVariable("jx");
kameleon2.unloadVariable("rho");
kameleon2.unloadVariable("ux");
// WRITE THE VTK FILE FOR RENDERING
std::string resultfilename;
std::cout << "Starting VTK Write" << std::endl;
resultfilename = dirname;
resultfilename.append("Results/");
resultfilename.append(boost::lexical_cast<std::string>(dset1[runi]));
resultfilename.append("_");
resultfilename.append(boost::lexical_cast<std::string>(dset2[runi]));
resultfilename.append("/Result");
resultfilename.append(boost::lexical_cast<std::string>(loopnum));
resultfilename.append(".vtk");
std::cout << "Result File Name is: " << resultfilename << std::endl;
// BINARY VTK FILE
float val, val1, val2;
FILE *myfile;
myfile = fopen(resultfilename.c_str(),"w");
fprintf(myfile, "# vtk DataFile Version 3.0\n");
fprintf(myfile, "Brian's Data\nBINARY\n");
fprintf(myfile, "DATASET RECTILINEAR_GRID\n");
fprintf(myfile, "DIMENSIONS %d %d %d\n", npoinx, npoiny, npoinz);
fprintf(myfile, "X_COORDINATES %d float\n", npoinx);
for (i=0; i<npoinx; i++){
val = FloatSwap(xcord[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nY_COORDINATES %d float\n", npoiny);
for (i=0; i<npoiny; i++){
val = FloatSwap(ycord[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nZ_COORDINATES %d float\n", npoinz);
for (i=0; i<npoinz; i++){
val = FloatSwap(zcord[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nPOINT_DATA %d\n", npoinx*npoiny*npoinz);
fprintf(myfile, "\nSCALARS Bz_Diff FLOAT 1\n");
fprintf(myfile, "LOOKUP_TABLE default\n");
for (i=0; i<npoinx*npoiny*npoinz; i++){
//val = FloatSwap(value[m][i]);
val = FloatSwap(diff(0,i));
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nSCALARS Jx_Diff FLOAT 1\n");
fprintf(myfile, "LOOKUP_TABLE default\n");
for (i=0; i<npoinx*npoiny*npoinz; i++){
//val = FloatSwap(value[m][i]);
val = FloatSwap(diff(1,i));
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nSCALARS rho_Diff FLOAT 1\n");
fprintf(myfile, "LOOKUP_TABLE default\n");
for (i=0; i<npoinx*npoiny*npoinz; i++){
//val = FloatSwap(value[m][i]);
val = FloatSwap(diff(2,i));
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nSCALARS Ux_Diff FLOAT 1\n");
fprintf(myfile, "LOOKUP_TABLE default\n");
for (i=0; i<npoinx*npoiny*npoinz; i++){
//val = FloatSwap(value[m][i]);
val = FloatSwap(diff(3,i));
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fclose(myfile);
std::cout << "VTK Write Complete" << std::endl;
// FINISH WRITE OF VTK FILE FOR RENDERING
kameleon1.close();
kameleon2.close();
value.clear();
value2.clear();
diff.clear();
}
}
return 0;
}
main (int argc, char *argv[]) {
float PARMOD[10];
PARMOD[0]= 0.0;
PARMOD[1]= 0.0;
PARMOD[2]= 0.0;
PARMOD[3]=0.0;
PARMOD[4]=0.0;
PARMOD[5]=0.0;
PARMOD[6]=0.0;
int iopt;
int i,j,k;
float kp = 2.0;
float ps = 0.0;
float bxout,byout,bzout; // THESE NEED TO BE STORED IN MEMORY NOW
// TIMESTEP LOOP STARTS HERE
//int m;
//for(m=0;m<=72;m++){
// NEED TO CALCULATE Kp HERE
// NEED TO COMPARE Kp RESULT TO iopt AND SET
if(kp < 0.5){
iopt = 1;
}
else if(kp > 0.5 && kp < 1.5){
iopt = 2;
}
else if(kp > 1.5 && kp < 2.5){
iopt = 3;
}
else if(kp > 2.5 && kp < 3.5){
iopt = 4;
}
else if(kp > 3.5 && kp < 4.5){
iopt = 5;
}
else if(kp > 4.5 && kp < 5.5){
iopt = 6;
}
else if(kp > 5.5){
iopt = 7;
}
// CREATE GRID AND STORE IN MEMORY
int npoinx = 345, npoiny = 187, npoinz = 187;
int xmin=-222, ymin=-47, zmin=ymin;
int xmax=30, ymax=47, zmax=ymax;
//float *xcord = new float[npoinx];
float *xcord = malloc(npoinx * sizeof(float));
xcord[0] = xmin;
// X COORDINATES
i = 0;
while (xcord[i] < xmax){
i++;
if(xcord[i-1] < -30. || xcord[i-1] >= 30.){ xcord[i] = xcord[i-1]+1.; }
else if(xcord[i-1] < -8. || xcord[i-1] >= 8.){ xcord[i] = xcord[i-1]+0.5; }
else if(xcord[i-1] <= 0. || xcord[i-1] >= 0.){ xcord[i] = xcord[i-1]+0.25; }
}
i = 0;
//float *ycord = new float[npoiny];
float *ycord = malloc(npoiny * sizeof(float));
ycord[0] = ymin;
// Y COORDINATES
while (ycord[i] < ymax){
i++;
if(ycord[i-1] < -30. || ycord[i-1] >= 30.){ ycord[i] = ycord[i-1]+1.; }
else if(ycord[i-1] < -8. || ycord[i-1] >= 8.){ ycord[i] = ycord[i-1]+0.5; }
else if(ycord[i-1] <= 0. || ycord[i-1] >= 0.){ ycord[i] = ycord[i-1]+0.25; }
}
i = 0;
//float *zcord = new float[npoinz];
float *zcord = malloc(npoinz * sizeof(float));
zcord[0] = zmin;
// Z COORDINATES
while (zcord[i] < zmax){
i++;
if(zcord[i-1] < -30. || zcord[i-1] >= 30.){ zcord[i] = zcord[i-1]+1.; }
else if(zcord[i-1] < -8. || zcord[i-1] >= 8.){ zcord[i] = zcord[i-1]+0.5; }
else if(zcord[i-1] <= 0. || zcord[i-1] >= 0.){ zcord[i] = zcord[i-1]+0.25; }
}
// GRID LOOP STARTS HERE
int l=0;
float *bx = malloc(npoinx*npoiny*npoinz * sizeof(float));
float *by = malloc(npoiny*npoiny*npoinz * sizeof(float));
float *bz = malloc(npoinz*npoiny*npoinz * sizeof(float));
for ( k = 0; k < npoinz; k++){
for ( j = 0; j < npoiny; j++){
for ( i = 0; i < npoinx; i++){
// EACH NEW GRID POINT PASS THROUGH THIS FUNCTION
t89c_(&iopt,PARMOD,&ps,&xcord[i],&ycord[j],&zcord[k],&bxout,&byout,&bzout);
bx[l] = bxout;
by[l] = byout;
bz[l] = bzout;
//printf("bx=%f,by=%f,bz=%f\n",bxout,byout,bzout);
//return 0;
l++;
}
}
}
//}
// WRITE VTK FILE
std::cout << "Starting VTK Write" << std::endl;
resultfilename = "/home/bcurtis/Tsyganenko/output/";
resultfilename.append("/Result");
resultfilename.append(boost::lexical_cast<std::string>(m));
resultfilename.append(".vtk");
std::cout << "Result File Name is: " << resultfilename << std::endl;
// SPRINTF??????
// BINARY VTK FILE
float val, val1, val2;
FILE *myfile;
myfile = fopen(resultfilename.c_str(),"w");
fprintf(myfile, "# vtk DataFile Version 3.0\n");
fprintf(myfile, "Brian's Data\nBINARY\n");
fprintf(myfile, "DATASET RECTILINEAR_GRID\n");
fprintf(myfile, "DIMENSIONS %d %d %d\n", npoinx, npoiny, npoinz);
fprintf(myfile, "X_COORDINATES %d float\n", npoinx);
for (i=0; i<npoinx; i++){
val = FloatSwap(xcord[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nY_COORDINATES %d float\n", npoiny);
for (i=0; i<npoiny; i++){
val = FloatSwap(ycord[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nZ_COORDINATES %d float\n", npoinz);
for (i=0; i<npoinz; i++){
val = FloatSwap(zcord[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nPOINT_DATA %d\n", npoinx*npoiny*npoinz);
fprintf(myfile, "\nSCALARS Bx FLOAT 1\n");
fprintf(myfile, "LOOKUP_TABLE default\n");
for (i=0; i<npoinx*npoiny*npoinz; i++){
val = FloatSwap(bx[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nSCALARS By FLOAT 1\n");
fprintf(myfile, "LOOKUP_TABLE default\n");
for (i=0; i<npoinx*npoiny*npoinz; i++){
val = FloatSwap(by[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fprintf(myfile, "\nSCALARS Bz FLOAT 1\n");
fprintf(myfile, "LOOKUP_TABLE default\n");
for (i=0; i<npoinx*npoiny*npoinz; i++){
val = FloatSwap(bz[i]);
fwrite((void *)&val, sizeof(float), 1, myfile);
}
fclose(myfile);
std::cout << "VTK Write Complete" << std::endl;
free(xcord); free(bx);
free(ycord); free(by);
free(zcord); free(bz);
return 1;
}
