FORUM Tom's Hardware » Programmation » C / C++ / Java » aide modification d'un fichier en c
 

aide modification d'un fichier en c

Matériel : error-404 Le monde de Windows : TONY571 Shopping en ligne : tisote Mobilité : kris_tofe, 2 utilisateurs anonymes et 413 utilisateurs inconnus
Ajouter une réponse



 Mot :   Pseudo :  
 
Bas de page
Auteur
 Sujet : aide modification d'un fichier en c
 
laroche1
Plus d'informations
n°30208
29-04-2007 à 12:25:11

Bonjour,
Voila je dois modifier un code en c , mais ce dernier n'etant pas été réalisé par moi , je suis totalement perdue.

Voila c'est un peu compliqué comme modification.
Dans le fichier original (fichier toto.c), on demande de lire un autre fichier X c'est à dire lire le jour et la position , les composantes et calculer la moyenne par case suivant des incréments definis. A la fin mon fichier de sortie donne la moyenne et j'obtiens un nombre différent de lignes puisque je fais le calcul par case.

Maintenant, il faudrait que je retrouve dans mon fichier de sortie le jour et la position de mon fichier X , de reprendre les valeurs de moyenne que j'ai obtenu dans le 1er exemple et donc par conséquent retrouver le meme nombre de lignes que mon fichier X (data_in doit etre egale à filled_bin (cf fichier de mon fichier en c)) et de calculer les écarts entre les comosantes de mon fichier X et les données moyennes.

Or mon probleme c'est que je n'arrive pas à voir ou je dois faire toutes ces modifications et donc je fais appel à vous tous. C'est surtout dans l'ecriture des fichiers de sorties (je pense...mais c pas sur )

Mon fichier en .c qui permet de me calculer la moyenne

Voici la ligne de commande que j'utilise
toto.exe 2 (pour avoir la moyenne) fichier X (fichier d'entreé) toto(fichier de sortie) 350 450 -80 -10 0 130 0.25 0.25 100

Code :
  1. [*]/****************************************************************************/
  2. /****    binthedata.c                                                    ****/
  3. /****                                                                    ****/
  4. /****    Lecture des donnees mars et "binnage" au format mgsab          ****/
  5. /****    format (temps), lat, lon, alt, Br, Btheta, Bphi                ****/
  6. /****************************************************************************/
  8. /***********************/
  9. /****    includes    ***/
  10. /***********************/
  12. #include <stdlib.h>
  13. #include <stdio.h>
  14. #include <math.h>
  15. #include <malloc.h>
  17. /**********************/
  18. /****    Define    ****/
  19. /**********************/
  21. #define M_PI  3.14159265358979323846
  22. #define PI_180 (M_PI / 180.0)
  23. #define RM 3393.5
  24. #define AMP (int)(alt_max-alt_min)
  25. /***********************/
  26. /****    Formats    ****/
  27. /***********************/
  29. #define READ_bin "%lf %lf %lf %lf %lf %lf %lf %d %lf %lf %lf\n"
  30. #define READs "%lf %lf %lf %lf %lf %lf\n"
  31. #define READl "%lf %lf %lf %lf %lf %lf %lf\n"
  32. #define READld "%lf %lf %lf %lf %lf %lf %lf %1s\n"
  33. #define LECTl1 &dday, &lon, &lat, &alt, &br, &bt, &bp
  34. #define LECTl2 &dday, &lat, &lon, &alt, &br, &bt, &bp
  35. #define LECTld &dday, &lat, &lon, &alt, &br, &bt, &bp, &dl
  36. #define READb "%lf %lf %lf %lf %lf %lf %d %lf %lf %lf\n"
  37. #define LECTb &lon, &lat, &alt, &br, &bt, &bp, &d, &dd, &dd, &dd
  39. #define WRITE_bin "%13.9lf %7.3lf %7.3lf %7.3lf %12.5lf %12.5lf %12.5lf %3d %10.3lf %10.3lf %10.3lf\n"
  41. #define WRITEs "%13.9lf %8.3lf %8.3lf %8.3lf %10.3lf %10.3lf %10.3lf\n"
  42. #define WRITEl "%13.9lf %8.3lf %8.3lf %8.3lf %10.3lf %10.3lf %10.3lf\n"
  43. #define ECRITl dday, lat, lon, alt, br, bt, bp
  44. #define WRITEld "%13.9lf %8.3lf %8.3lf %8.3lf %10.3lf %10.3lf %10.3lf %1s\n"
  45. #define ECRITld dday, lat, lon, alt, br, bt, bp, dl
  47. #define NMAX 50
  49. /****************************/
  50. /****    Main Program    ****/
  51. /****************************/
  53. int main(argc, argv)
  54. int argc;
  55. char *argv[];
  56.       {
  57.     FILE  *fin, *fout;
  58.     FILE  *fout_00, *fout_01, *fout_02, *fout_03, *fout_04;
  59.     FILE  *fout_05, *fout_06, *fout_07, *fout_08, *fout_09;
  60.     FILE  *fout_10, *fout_11, *fout_12, *fout_13, *fout_14;
  61.     FILE  *fout_15, *fout_16, *fout_17, *fout_18, *fout_19;
  62.     FILE  *fout_20, *fout_21, *fout_22, *fout_23, *fout_24;
  63.     FILE  *fout_25, *fout_26, *fout_27, *fout_28, *fout_29;
  64.     FILE  *fout_30, *fout_31, *fout_32, *fout_33, *fout_34;
  65.     FILE  *fout_35, *fout_36, *fout_37, *fout_38, *fout_39;
  66.     FILE  *fout_40, *fout_41, *fout_42, *fout_43, *fout_44;
  67.     FILE  *fout_45, *fout_46, *fout_47, *fout_48, *fout_49;
  68.     char  str[200];
  69.     double alt_max, alt_min;
  70.     double lat_max, lat_min;
  71.     double lon_max, lon_min;
  72.     int    choix;
  73.     int    data_in, data_out;
  74.     int    filled_bin=0;
  75.     int    filled_bin1=0;
  76.     int    filled_bin2=0;
  77.     double inc_lon, inc_lat, inc_alt;
  78.     double amp_lon, amp_lat, amp_alt;
  79.     int    npt_lon, npt_lat, npt_alt;
  80.     int    l, L, A;
  81.     double dday, lat, lon, alt, br, bt, bp;
  82.     int    index_alt;
  83.     int    npt_tot;
  84.     double **BR, **BT, **BP;
  85.     double **alt_var;
  86.     double *BR_max, *BT_max, *BP_max;
  87.     double *BR_min, *BT_min, *BP_min;
  88.     double *BR_moy, *BT_moy, *BP_moy;
  89.     double *BR_med, *BT_med, *BP_med;
  90.     double *BR_std, *BT_std, *BP_std;
  91.     double std_br, std_bt, std_bp;
  92.     double sum_br, sum_bt, sum_bp;
  93.     double dif_br, dif_bt, dif_bp;
  94.     int    i, j, k, index;
  95.     int    *NPT;
  96.     char dl[1];
  97.     double temp;
  98.     int d;
  99.     double dd;
  100.     dday = 0.0;
  102.     /* Introduction */
  103.    
  104.     printf("############################################################\n" );
  105.     printf("binthedata.exe\n\n" );
  107.     /* Test the number of parameters */
  109.     if (argc != 6 && argc != 10 && argc != 13)
  110.       {
  111.         printf("\tYou must call 6, 10 or 13 parameters!\n" );
  112.         printf("\tbinthedata.exe <choix> <fin> <fout> <alt_min> <alt_max>\n" );
  113.         printf("\tand eventually <lat_min> <lat_max> <lon_min> <<lon_max>\n" );
  114.         printf("\tand eventually <inc_lat> <inc_lon> <inc_alt>\n" );
  115.         printf("\t<choix> = 1 (median) or 2 (average) or 3 (minimum) or 4 (maximum)\n" );
  116.         printf("\t<choix> = 5 : one data per orbit per bin.\n" );
  117.         exit(-1);
  118.       }
  120.     choix = atoi(argv[1]);
  121.     if (choix != 1 && choix != 2 && choix != 3 && choix != 4 && choix != 5)
  122.       {
  123.         printf("\tBad <choix> value. Must be 1 <-> 5. Please check!\n" );
  124.         exit(-1);
  125.       }
  127.     fin = fopen(argv[2], "r" );
  128.     if (fin == NULL)
  129.       {
  130.         printf("Reading error on input file <%s>\n. Please check!\n", argv[2]);
  131.         exit(-1);
  132.       }
  134.     fout = fopen(argv[3], "w" );
  135.     if (fin == NULL)
  136.       {
  137.         printf("Writing error on output file <%s>\n. Please check!\n", argv[3]);
  138.         fclose(fin);
  139.         exit(-1);
  140.       }
  142.     /* Minimum and Maximum altitude */
  144.     alt_min = atof(argv[4]);
  145.     alt_max = atof(argv[5]);
  147.     if (argc == 10 || argc == 13)
  148.       {
  149.         lat_min = atof(argv[6]);
  150.         lat_max = atof(argv[7]);
  151.         lon_min = atof(argv[8]);
  152.         lon_max = atof(argv[9]);
  153.       }
  154.     else
  155.       {
  156.         lat_min = -90.;
  157.         lat_max = 90.;
  158.         lon_min = 0.;
  159.         lon_max = 360.;
  160.       }
  162.     if (argc == 13)
  163.       {
  164.         inc_lat = atof(argv[10]);
  165.         inc_lon = atof(argv[11]);
  166.         inc_alt = atof(argv[12]);
  167.       }
  168.     else
  169.       {
  170.         inc_lat = 1.;
  171.         inc_lon = 1.;
  172.         inc_alt = 10.;
  173.       }
  175.     /****    Verification    ****/
  177.     if (alt_min < 0.)
  178.       {
  179.         do
  180.           {
  181.         printf("\t<alt_min> lower than 0! Please enter a new value (0.)\n" );
  182.         fgets(str, 150, stdin);
  183.         if (str[0] == '\n')    alt_min = 0.;
  184.         else
  185.           {
  186.             sscanf(str, "%lf", &alt_min);
  187.           }
  188.           }
  189.         while (alt_max < 0.);
  190.       }
  191.     if (alt_max > 1000.)
  192.       {
  193.         do
  194.           {
  195.         printf("\t<alt_max> greater than 1000! Please enter a new value (1000.)\n" );
  196.         fgets(str, 150, stdin);
  197.         if (str[0] == '\n')    alt_max = 1000.;
  198.         else
  199.           {
  200.             sscanf(str, "%lf", &alt_max);
  201.           }
  202.           }
  203.         while (alt_max > 1000.);
  204.       }
  206.     if (alt_min > alt_max)
  207.       {
  208.         printf("\t<alt_min> greater than <alt_max>.\n" );
  209.         printf("\tPlease check. Exit!\n" );
  210.         fclose(fin);
  211.         exit(-1);
  212.       }
  214.     if (lat_min > lat_max)
  215.       {
  216.         printf("\tError in latitude range. Please check!\n" );
  217.         exit(-1);
  218.       }
  220.     /* parametres */
  222.     /* Initialisation */
  224.     amp_lat = lat_max - lat_min;
  225.     if (lon_max < lon_min)
  226.         amp_lon = 360. + lon_max - lon_min;
  227.     else
  228.         amp_lon = lon_max - lon_min;
  229.     amp_alt = alt_max - alt_min;
  231.     npt_lat = (int)(amp_lat / (double)inc_lat);
  232.     npt_lon = (int)(amp_lon / (double)inc_lon);
  233.     npt_alt = (int)(amp_alt / (double)inc_alt);
  235.     fprintf(stdout, "Nombre de points = %d (lat) x %d (lon) x %d (alt)\n",
  236.         npt_lat, npt_lon, npt_alt);
  238.     l = 0      ; L = 0      ; A = 0      ;
  239.     lat = lat_min + (double)l*inc_lat;
  240.     fprintf(stdout, "\tL'intervalle lat est %7.3lf/", lat);
  241.     l = npt_lat; L = 0      ; A = 0      ;
  242.     lat = lat_min + (double)l*inc_lat;
  243.     fprintf(stdout, "%7.3lf\n", lat);
  244.     l = 0      ; L = 0      ; A = 0      ;
  245.     lon = lon_min + (double)L*inc_lon;
  246.     fprintf(stdout, "\tL'intervalle lon est %7.3lf/", lon);
  247.     l = 0      ; L = npt_lon; A = 0      ;
  248.     lon = lon_min + (double)L*inc_lon;
  249.     fprintf(stdout, "%7.3lf\n", lon);
  250.     l = 0      ; L = 0      ; A = 0      ;
  251.     alt = alt_min + (double)A*inc_alt;
  252.     fprintf(stdout, "\tL'intervalle alt est %7.3lf/", alt);
  253.     l = 0      ; L = 0      ; A = npt_alt;
  254.     alt = alt_min + (double)A*inc_alt;
  255.     fprintf(stdout, "%7.3lf\n", alt);
  256.     fflush(stdout);
  258.     /****    Lecture et ecriture des donnees triees par altitude    ****/
  260.     fprintf(stdout, "\n\tOuverture des fichiers" );
  261.     fflush(stdout);
  262.     fout_00 = fopen("temp_00.alt", "w" );
  263.     fout_01 = fopen("temp_01.alt", "w" );
  264.     fout_02 = fopen("temp_02.alt", "w" );
  265.     fout_03 = fopen("temp_03.alt", "w" );
  266.     fout_04 = fopen("temp_04.alt", "w" );
  267.     fout_05 = fopen("temp_05.alt", "w" );
  268.     fout_06 = fopen("temp_06.alt", "w" );
  269.     fout_07 = fopen("temp_07.alt", "w" );
  270.     fout_08 = fopen("temp_08.alt", "w" );
  271.     fout_09 = fopen("temp_09.alt", "w" );
  272.     fout_10 = fopen("temp_10.alt", "w" );
  273.     fout_11 = fopen("temp_11.alt", "w" );
  274.     fout_12 = fopen("temp_12.alt", "w" );
  275.     fout_13 = fopen("temp_13.alt", "w" );
  276.     fout_14 = fopen("temp_14.alt", "w" );
  277.     fout_15 = fopen("temp_15.alt", "w" );
  278.     fout_16 = fopen("temp_16.alt", "w" );
  279.     fout_17 = fopen("temp_17.alt", "w" );
  280.     fout_18 = fopen("temp_18.alt", "w" );
  281.     fout_19 = fopen("temp_19.alt", "w" );
  282.     fout_20 = fopen("temp_20.alt", "w" );
  283.     fout_21 = fopen("temp_21.alt", "w" );
  284.     fout_22 = fopen("temp_22.alt", "w" );
  285.     fout_23 = fopen("temp_23.alt", "w" );
  286.     fout_24 = fopen("temp_24.alt", "w" );
  287.     fout_25 = fopen("temp_25.alt", "w" );
  288.     fout_26 = fopen("temp_26.alt", "w" );
  289.     fout_27 = fopen("temp_27.alt", "w" );
  290.     fout_28 = fopen("temp_28.alt", "w" );
  291.     fout_29 = fopen("temp_29.alt", "w" );
  292.     fout_30 = fopen("temp_30.alt", "w" );
  293.     fout_31 = fopen("temp_31.alt", "w" );
  294.     fout_32 = fopen("temp_32.alt", "w" );
  295.     fout_33 = fopen("temp_33.alt", "w" );
  296.     fout_34 = fopen("temp_34.alt", "w" );
  297.     fout_35 = fopen("temp_35.alt", "w" );
  298.     fout_36 = fopen("temp_36.alt", "w" );
  299.     fout_37 = fopen("temp_37.alt", "w" );
  300.     fout_38 = fopen("temp_38.alt", "w" );
  301.     fout_39 = fopen("temp_39.alt", "w" );
  302.     fout_40 = fopen("temp_40.alt", "w" );
  303.     fout_41 = fopen("temp_41.alt", "w" );
  304.     fout_42 = fopen("temp_42.alt", "w" );
  305.     fout_43 = fopen("temp_43.alt", "w" );
  306.     fout_44 = fopen("temp_44.alt", "w" );
  307.     fout_45 = fopen("temp_45.alt", "w" );
  308.     fout_46 = fopen("temp_46.alt", "w" );
  309.     fout_47 = fopen("temp_47.alt", "w" );
  310.     fout_48 = fopen("temp_48.alt", "w" );
  311.     fout_49 = fopen("temp_49.alt", "w" );
  313.     data_in = data_out = 0;
  315.     fprintf(stdout,"\tLecture et tri par altitude...\n" );
  316.     fflush(stdout);
  317.     while(!feof(fin))
  318.       {
  319. /*         fscanf(fin, READl, LECTl1); */
  320. /*         fscanf(fin, READl, LECTl2); */
  321.         fscanf(fin, READld, LECTld);
  322.         data_in ++;
  323.         if (lon < 0.)lon += 360.;
  324.         else if (lon >= 360.)lon -= 360.;
  325.         if (lat >= lat_min && lat < lat_max && alt >= alt_min && alt < alt_max)
  326.           {
  327.         if ((lon_min < lon_max && lon >= lon_min && lon < lon_max) ||
  328.             (lon_min > lon_max && (lon >= lon_min || lon < lon_max)))
  329.           {
  330.             index_alt = (int)((alt - alt_min)/inc_alt);
  331.             data_out ++;
  332.             switch(index_alt)
  333.               {
  334.               case 0:
  335.             {
  336.               fprintf(fout_00, WRITEl, ECRITl);
  337.               break;
  338.             }
  339.               case 1:
  340.             {
  341.               fprintf(fout_01, WRITEl, ECRITl);
  342.               break;
  343.             }
  344.               case 2:
  345.             {
  346.               fprintf(fout_02, WRITEl, ECRITl);
  347.               break;
  348.             }
  349.               case 3:
  350.             {
  351.               fprintf(fout_03, WRITEl, ECRITl);
  352.               break;
  353.             }
  354.               case 4:
  355.             {
  356.               fprintf(fout_04, WRITEl, ECRITl);
  357.               break;
  358.             }
  359.               case 5:
  360.             {
  361.               fprintf(fout_05, WRITEl, ECRITl);
  362.               break;
  363.             }
  364.               case 6:
  365.             {
  366.               fprintf(fout_06, WRITEl, ECRITl);
  367.               break;
  368.             }
  369.               case 7:
  370.             {
  371.               fprintf(fout_07, WRITEl, ECRITl);
  372.               break;
  373.             }
  374.               case 8:
  375.             {
  376.               fprintf(fout_08, WRITEl, ECRITl);
  377.               break;
  378.             }
  379.               case 9:
  380.             {
  381.               fprintf(fout_09, WRITEl, ECRITl);
  382.               break;
  383.             }
  384.               case 10:
  385.             {
  386.               fprintf(fout_10, WRITEl, ECRITl);
  387.               break;
  388.             }
  389.               case 11:
  390.             {
  391.               fprintf(fout_11, WRITEl, ECRITl);
  392.               break;
  393.             }
  394.               case 12:
  395.             {
  396.               fprintf(fout_12, WRITEl, ECRITl);
  397.               break;
  398.             }
  399.               case 13:
  400.             {
  401.               fprintf(fout_13, WRITEl, ECRITl);
  402.               break;
  403.             }
  404.               case 14:
  405.             {
  406.               fprintf(fout_14, WRITEl, ECRITl);
  407.               break;
  408.             }
  409.               case 15:
  410.             {
  411.               fprintf(fout_15, WRITEl, ECRITl);
  412.               break;
  413.             }
  414.               case 16:
  415.             {
  416.               fprintf(fout_16, WRITEl, ECRITl);
  417.               break;
  418.             }
  419.               case 17:
  420.             {
  421.               fprintf(fout_17, WRITEl, ECRITl);
  422.               break;
  423.             }
  424.               case 18:
  425.             {
  426.               fprintf(fout_18, WRITEl, ECRITl);
  427.               break;
  428.             }
  429.               case 19:
  430.             {
  431.               fprintf(fout_19, WRITEl, ECRITl);
  432.               break;
  433.             }
  434.               case 20:
  435.             {
  436.               fprintf(fout_20, WRITEl, ECRITl);
  437.               break;
  438.             }
  439.               case 21:
  440.             {
  441.               fprintf(fout_21, WRITEl, ECRITl);
  442.               break;
  443.             }
  444.               case 22:
  445.             {
  446.               fprintf(fout_22, WRITEl, ECRITl);
  447.               break;
  448.             }
  449.               case 23:
  450.             {
  451.               fprintf(fout_23, WRITEl, ECRITl);
  452.               break;
  453.             }
  454.               case 24:
  455.             {
  456.               fprintf(fout_24, WRITEl, ECRITl);
  457.               break;
  458.             }
  459.               case 25:
  460.             {
  461.               fprintf(fout_25, WRITEl, ECRITl);
  462.               break;
  463.             }
  464.               case 26:
  465.             {
  466.               fprintf(fout_26, WRITEl, ECRITl);
  467.               break;
  468.             }
  469.               case 27:
  470.             {
  471.               fprintf(fout_27, WRITEl, ECRITl);
  472.               break;
  473.             }
  474.               case 28:
  475.             {
  476.               fprintf(fout_28, WRITEl, ECRITl);
  477.               break;
  478.             }
  479.               case 29:
  480.             {
  481.               fprintf(fout_29, WRITEl, ECRITl);
  482.               break;
  483.             }
  484.               case 30:
  485.             {
  486.               fprintf(fout_30, WRITEl, ECRITl);
  487.               break;
  488.             }
  489.               case 31:
  490.             {
  491.               fprintf(fout_31, WRITEl, ECRITl);
  492.               break;
  493.             }
  494.               case 32:
  495.             {
  496.               fprintf(fout_32, WRITEl, ECRITl);
  497.               break;
  498.             }
  499.               case 33:
  500.             {
  501.               fprintf(fout_33, WRITEl, ECRITl);
  502.               break;
  503.             }
  504.               case 34:
  505.             {
  506.               fprintf(fout_34, WRITEl, ECRITl);
  507.               break;
  508.             }
  509.               case 35:
  510.             {
  511.               fprintf(fout_35, WRITEl, ECRITl);
  512.               break;
  513.             }
  514.               case 36:
  515.             {
  516.               fprintf(fout_36, WRITEl, ECRITl);
  517.               break;
  518.             }
  519.               case 37:
  520.             {
  521.               fprintf(fout_37, WRITEl, ECRITl);
  522.               break;
  523.             }
  524.               case 38:
  525.             {
  526.               fprintf(fout_38, WRITEl, ECRITl);
  527.               break;
  528.             }
  529.               case 39:
  530.             {
  531.               fprintf(fout_39, WRITEl, ECRITl);
  532.               break;
  533.             }
  534.               case 40:
  535.             {
  536.               fprintf(fout_40, WRITEl, ECRITl);
  537.               break;
  538.             }
  539.               case 41:
  540.             {
  541.               fprintf(fout_41, WRITEl, ECRITl);
  542.               break;
  543.             }
  544.               case 42:
  545.             {
  546.               fprintf(fout_42, WRITEl, ECRITl);
  547.               break;
  548.             }
  549.               case 43:
  550.             {
  551.               fprintf(fout_43, WRITEl, ECRITl);
  552.               break;
  553.             }
  554.               case 44:
  555.             {
  556.               fprintf(fout_44, WRITEl, ECRITl);
  557.               break;
  558.             }
  559.               case 45:
  560.             {
  561.               fprintf(fout_45, WRITEl, ECRITl);
  562.               break;
  563.             }
  564.               case 46:
  565.             {
  566.               fprintf(fout_46, WRITEl, ECRITl);
  567.               break;
  568.             }
  569.               case 47:
  570.             {
  571.               fprintf(fout_47, WRITEl, ECRITl);
  572.               break;
  573.             }
  574.               case 48:
  575.             {
  576.               fprintf(fout_48, WRITEl, ECRITl);
  577.               break;
  578.             }
  579.               case 49:
  580.             {
  581.               fprintf(fout_49, WRITEl, ECRITl);
  582.               break;
  583.             }
  584.               }
  585.           }
  586.           }
  587.       }
  589.     fclose(fout_00);
  590.     fclose(fout_01);
  591.     fclose(fout_02);
  592.     fclose(fout_03);
  593.     fclose(fout_04);
  594.     fclose(fout_05);
  595.     fclose(fout_06);
  596.     fclose(fout_07);
  597.     fclose(fout_08);
  598.     fclose(fout_09);
  599.     fclose(fout_10);
  600.     fclose(fout_11);
  601.     fclose(fout_12);
  602.     fclose(fout_13);
  603.     fclose(fout_14);
  604.     fclose(fout_15);
  605.     fclose(fout_16);
  606.     fclose(fout_17);
  607.     fclose(fout_18);
  608.     fclose(fout_19);
  609.     fclose(fout_20);
  610.     fclose(fout_21);
  611.     fclose(fout_22);
  612.     fclose(fout_23);
  613.     fclose(fout_24);
  614.     fclose(fout_25);
  615.     fclose(fout_26);
  616.     fclose(fout_27);
  617.     fclose(fout_28);
  618.     fclose(fout_29);
  619.     fclose(fout_30);
  620.     fclose(fout_31);
  621.     fclose(fout_32);
  622.     fclose(fout_33);
  623.     fclose(fout_34);
  624.     fclose(fout_35);
  625.     fclose(fout_36);
  626.     fclose(fout_37);
  627.     fclose(fout_38);
  628.     fclose(fout_39);
  629.     fclose(fout_40);
  630.     fclose(fout_41);
  631.     fclose(fout_42);
  632.     fclose(fout_43);
  633.     fclose(fout_44);
  634.     fclose(fout_45);
  635.     fclose(fout_46);
  636.     fclose(fout_47);
  637.     fclose(fout_48);
  638.     fclose(fout_49);
  640.     fclose(fin);
  642.     /****    Lecture fichier par fichier    ****/
  644.     fprintf(stdout,"\n\tLecture OK. Travail par bande d'altitude\n" );
  645.     fflush(stdout);
  647.     npt_tot = npt_lat * npt_lon;
  649.     BR = (double **)malloc(npt_tot*sizeof(double*));
  650.     BT = (double **)malloc(npt_tot*sizeof(double*));
  651.     BP = (double **)malloc(npt_tot*sizeof(double*));
  652.     alt_var = (double **)malloc(npt_tot*sizeof(double*));
  653.     for (i = 0; i < npt_tot; i++)
  654.       {
  655.         BR[i] = (double *)malloc(NMAX*sizeof(double));
  656.         BT[i] = (double *)malloc(NMAX*sizeof(double));
  657.         BP[i] = (double *)malloc(NMAX*sizeof(double));
  658.         alt_var[i] = (double *)malloc(NMAX*sizeof(double));
  659.       }
  661.     if (choix == 1)
  662.       {
  663.         BR_med = (double *)malloc(npt_tot*sizeof(double));
  664.         BT_med = (double *)malloc(npt_tot*sizeof(double));
  665.         BP_med = (double *)malloc(npt_tot*sizeof(double));
  666.       }
  667.     else if (choix == 2)
  668.       {
  669.         BR_moy = (double *)malloc(npt_tot*sizeof(double));
  670.         BT_moy = (double *)malloc(npt_tot*sizeof(double));
  671.         BP_moy = (double *)malloc(npt_tot*sizeof(double));
  672.       }
  673.     else if (choix == 3)
  674.       {
  675.         BR_min = (double *)malloc(npt_tot*sizeof(double));
  676.         BT_min = (double *)malloc(npt_tot*sizeof(double));
  677.         BP_min = (double *)malloc(npt_tot*sizeof(double));
  678.       }
  679.     else if (choix == 4)
  680.       {
  681.         BR_max = (double *)malloc(npt_tot*sizeof(double));
  682.         BT_max = (double *)malloc(npt_tot*sizeof(double));
  683.         BP_max = (double *)malloc(npt_tot*sizeof(double));
  684.       }
  685.     BR_std = (double *)malloc(npt_tot*sizeof(double));
  686.     BT_std = (double *)malloc(npt_tot*sizeof(double));
  687.     BP_std = (double *)malloc(npt_tot*sizeof(double));
  689.     NPT = (int *)malloc(npt_tot*sizeof(int*));
  691.     BR[0][0] = 0.;
  692.     for (A = 0; A < 50 ; A ++)
  693.       {
  694.         fprintf(stdout, "\t\tAltitude = %lf\n", (double)(A * inc_alt) + alt_min);
  695.         sprintf(str, "temp_%02d.alt", A);
  696.         fin = fopen(str, "r" );
  698.         for (i = 0 ; i < npt_tot ; i ++)
  699.           {
  700.         NPT[i] = 0;
  701.           }
  702.         while (!feof(fin))
  703.           {
  704.         d = fscanf(fin, READl, LECTl2);
  705.         if (d == 7)
  706.           {
  707.             l = (lat - lat_min) / inc_lat;
  708.             if (lon_max > lon_min)
  709.               {
  710.             L = (int)((lon - lon_min ) / inc_lon);
  711.               }
  712.             else
  713.               {
  714.             if (lon >= lon_min)
  715.               {
  716.                 L = (int)((lon - lon_min ) /inc_lon);
  717.               }
  718.             else
  719.               {
  720.                 L = (int)((lon + 360. - lon_min ) /inc_lon);
  721.               }
  722.               }
  725.             index = l * npt_lon + L;
  726.             for (i = 0 ; i < NPT[index]; i++)
  727.               {
  728.             if (br < BR[index][i])
  729.               {
  730.                 temp = BR[index][i];
  731. /*                 j = i; */
  732. /*                 fprintf(stdout," %d\n",j);fflush(stdout); */
  733.                 BR[index][i] = br;
  734.                 br = temp;
  735.                 for (j = i+1 ; j < NPT[index]; j++)
  736.                   {
  737.                 temp = BR[index][j];
  738.                 BR[index][j] = br;
  739.                 br = temp;
  740.                   }
  741.                 break;
  742.               }
  743.               }
  744.             BR[index][NPT[index]] = br;
  745.            
  746.             for (i = 0 ; i < NPT[index]; i++)
  747.               {
  748.             if (bt < BT[index][i])
  749.               {
  750.                 temp = BT[index][i];
  751.                 BT[index][i] = bt;
  752.                 bt = temp;
  753.                 for (j = i+1 ; j < NPT[index]; j++)
  754.                   {
  755.                 temp = BT[index][j];
  756.                 BT[index][j] = bt;
  757.                 bt = temp;
  758.                   }
  759.                 break;
  760.               }
  761.               }
  762.             BT[index][NPT[index]] = bt;
  763.            
  764.             for (i = 0 ; i < NPT[index]; i++)
  765.               {
  766.             if (bp < BP[index][i])
  767.               {
  768.                 temp = BP[index][i];
  769.                 BP[index][i] = bp;
  770.                 bp = temp;
  771.                 for (j = i+1 ; j < NPT[index]; j++)
  772.                   {
  773.                 temp = BP[index][j];
  774.                 BP[index][j] = bp;
  775.                 bp = temp;
  776.                   }
  777.                 break;
  778.               }
  779.               }
  780.             BP[index][NPT[index]] = bp;
  782.             alt_var[index][NPT[index]] = alt;
  784.             NPT[index] += 1;
  786.            
  787. /*         fprintf(stdout, "Case %d, %d points lus\n", index, NPT[index]);fflush(stdout); */
  788.           }
  789.           }
  790.         fclose(fin);
  792.         if (choix == 1)
  793.           {
  794.         for (l = 0 ; l < npt_lat; l++)
  795.           {
  796.             for (L = 0 ; L < npt_lon ; L++)
  797.               {
  798.             index = l * npt_lon + L;
  799.             if (NPT[index] > 0)
  800.               {
  801. /*                 for (k = 0 ; k < NPT[index]; k++) */
  802. /*                   { */
  803. /*                 fprintf(stdout, "%3d %8.3lf %8.3lf %8.3lf\n", k,BR[index][k],BT[index][k],BP[index][k]);fflush(stdout); */
  804. /*                   } */
  805.                 if (NPT[index] == 1)
  806.                   {
  807.                 BR_med[index]=BR[index][NPT[index]-1];
  808.                 BT_med[index]=BT[index][NPT[index]-1];
  809.                 BP_med[index]=BP[index][NPT[index]-1];
  810.                   }
  811.                 else if ( NPT[index]%2 == 0)
  812.                   {
  813.                 BR_med[index]=(BR[index][NPT[index]/2-1]+BR[index][NPT[index]/2])/2.;
  814.                 BT_med[index]=(BT[index][NPT[index]/2-1]+BT[index][NPT[index]/2])/2.;
  815.                 BP_med[index]=(BP[index][NPT[index]/2-1]+BP[index][NPT[index]/2])/2.;
  816.                   }
  817.                 else if ( NPT[index]%2 != 0)
  818.                   {
  819.                 BR_med[index]=BR[index][(NPT[index]-1)/2];
  820.                 BT_med[index]=BT[index][(NPT[index]-1)/2];
  821.                 BP_med[index]=BP[index][(NPT[index]-1)/2];
  822.                   }
  824.                 std_br = std_bt = std_bp = 0;
  826.                 for (k = 0; k < NPT[index] ; k ++)
  827.                   {
  828.                 dif_br = (BR[index][k] - BR_med[index]);
  829.                 std_br  += dif_br*dif_br;
  830.                 dif_bt = (BT[index][k] - BT_med[index]);
  831.                 std_bt  += dif_bt*dif_bt;
  832.                 dif_bp = (BP[index][k] - BP_med[index]);
  833.                 std_bp  += dif_bp*dif_bp;
  834.                   }
  835.                 if (NPT[index] > 2)
  836.                   {
  837.                 BR_std[index] = sqrt(std_br/(NPT[index]-1));
  838.                 BT_std[index] = sqrt(std_bt/(NPT[index]-1));
  839.                 BP_std[index] = sqrt(std_bp/(NPT[index]-1));
  840.                   }
  841.                 else
  842.                   {
  843.                 BR_std[index] = 3.;
  844.                 BT_std[index] = 3.;
  845.                 BP_std[index] = 3.;
  846.                   }
  847.                 lat = lat_min + (double)l*inc_lat + inc_lat/2.;
  848.                 lon = lon_min + (double)L*inc_lon + inc_lon/2.;
  849.                 alt = alt_min + (double)A*inc_alt + inc_alt/2.;
  850.                
  851.                 fprintf(fout, WRITE_bin, dday, lon, lat, alt,
  852.                     BR_med[index], BT_med[index], BP_med[index],
  853.                     NPT[index],
  854.                     BR_std[index], BT_std[index], BP_std[index]);
  856.               }
  857.               }
  858.           }
  859.           }
  861.         else if (choix == 2)
  862.           {
  863.         for (l = 0 ; l < npt_lat; l++)
  864.           {
  865.             for (L = 0 ; L < npt_lon ; L++)
  866.               {
  867.             index = l * npt_lon + L;
  868.             if (NPT[index] > 0)
  869.               {
  870.                 sum_br = sum_bt = sum_bp = 0.;
  871.                 for (k = 0; k < NPT[index] ; k ++)
  872.                   {
  873.                 sum_br += BR[index][k];
  874.                 sum_bt += BT[index][k];
  875.                 sum_bp += BP[index][k];
  876.                   }
  877.                 BR_moy[index] = sum_br / (double)NPT[index];
  878.                 BT_moy[index] = sum_bt / (double)NPT[index];
  879.                 BP_moy[index] = sum_bp / (double)NPT[index];
  881.                 std_br = std_bt = std_bp = 0;
  883.                 for (k = 0; k < NPT[index] ; k ++)
  884.                   {
  885.                 dif_br = (BR[index][i] - BR_moy[index]);
  886.                 std_br  += dif_br*dif_br;
  887.                 dif_bt = (BT[index][i] - BT_moy[index]);
  888.                 std_bt  += dif_bt*dif_bt;
  889.                 dif_bp = (BP[index][i] - BP_moy[index]);
  890.                 std_bp  += dif_bp*dif_bp;
  891.                   }
  892.                 if (NPT[index] > 2)
  893.                   {
  894.                 BR_std[index] = sqrt(std_br/(NPT[index]-1));
  895.                 BT_std[index] = sqrt(std_bt/(NPT[index]-1));
  896.                 BP_std[index] = sqrt(std_bp/(NPT[index]-1));
  897.                   }
  898.                 else
  899.                   {
  900.                 BR_std[index] = 3.;
  901.                 BT_std[index] = 3.;
  902.                 BP_std[index] = 3.;
  903.                   }
  904.                 lat = lat_min + (double)l*inc_lat + inc_lat/2.;
  905.                 lon = lon_min + (double)L*inc_lon + inc_lon/2.;
  906.                 if (lon >= 360.)
  907.                   lon -= 360.;
  908.                 alt = alt_min + (double)A*inc_alt + inc_alt/2.;
  910.                 fprintf(fout, WRITE_bin, dday, lon, lat, alt,
  911.                     BR_moy[index], BT_moy[index], BP_moy[index],
  912.                     NPT[index],
  913.                     BR_std[index], BT_std[index], BP_std[index]);
  914.               }
  915.               }
  916.           }
  917.           }
  920.         else if (choix == 3)
  921.           {
  922.         for (l = 0 ; l < npt_lat; l++)
  923.           {
  924.             for (L = 0 ; L < npt_lon ; L++)
  925.               {
  926.             index = l * npt_lon + L;
  927.             if (NPT[index] > 0)
  928.               {
  929.                 BR_min[index] = BR[index][0];
  930.                 BT_min[index] = BT[index][0];
  931.                 BP_min[index] = BP[index][0];
  933.                 std_br = std_bt = std_bp = 0;
  935.                 for (k = 0; k < NPT[index] ; k ++)
  936.                   {
  937.                 dif_br = (BR[index][i] - BR_min[index]);
  938.                 std_br  += dif_br*dif_br;
  939.                 dif_bt = (BT[index][i] - BT_min[index]);
  940.                 std_bt  += dif_bt*dif_bt;
  941.                 dif_bp = (BP[index][i] - BP_min[index]);
  942.                 std_bp  += dif_bp*dif_bp;
  943.                   }
  944.                 if (NPT[index] > 2)
  945.                   {
  946.                 BR_std[index] = sqrt(std_br/(NPT[index]-1));
  947.                 BT_std[index] = sqrt(std_bt/(NPT[index]-1));
  948.                 BP_std[index] = sqrt(std_bp/(NPT[index]-1));
  949.                   }
  950.                 else
  951.                   {
  952.                 BR_std[index] = 3.;
  953.                 BT_std[index] = 3.;
  954.                 BP_std[index] = 3.;
  955.                   }
  956.                 lat = lat_min + (double)l*inc_lat + inc_lat/2.;
  957.                 lon = lon_min + (double)L*inc_lon + inc_lon/2.;
  958.                 if (lon >= 360.)
  959.                   lon -= 360.;
  960.                 alt = alt_min + (double)A*inc_alt + inc_alt/2.;
  962.                 fprintf(fout, WRITE_bin, dday, lon, lat, alt,
  963.                     BR_min[index], BT_min[index], BP_min[index],
  964.                     NPT[index],
  965.                     BR_std[index], BT_std[index], BP_std[index]);
  966.               }
  967.               }
  968.           }
  969.           }
  971.         else if (choix == 4)
  972.           {
  973.         for (l = 0 ; l < npt_lat; l++)
  974.           {
  975.             for (L = 0 ; L < npt_lon ; L++)
  976.               {
  977.             index = l * npt_lon + L;
  978.             if (NPT[index] > 0)
  979.               {
  980.                 BR_max[index] = BR[index][NPT[index]-1];
  981.                 BT_max[index] = BT[index][NPT[index]-1];
  982.                 BP_max[index] = BP[index][NPT[index]-1];
  984.                 std_br = std_bt = std_bp = 0;
  986.                 for (k = 0; k < NPT[index] ; k ++)
  987.                   {
  988.                 dif_br = (BR[index][i] - BR_max[index]);
  989.                 std_br  += dif_br*dif_br;
  990.                 dif_bt = (BT[index][i] - BT_max[index]);
  991.                 std_bt  += dif_bt*dif_bt;
  992.                 dif_bp = (BP[index][i] - BP_max[index]);
  993.                 std_bp  += dif_bp*dif_bp;
  994.                   }
  995.                 if (NPT[index] > 2)
  996.                   {
  997.                 BR_std[index] = sqrt(std_br/(NPT[index]-1));
  998.                 BT_std[index] = sqrt(std_bt/(NPT[index]-1));
  999.                 BP_std[index] = sqrt(std_bp/(NPT[index]-1));
  1000.                   }
  1001.                 else
  1002.                   {
  1003.                 BR_std[index] = 3.;
  1004.                 BT_std[index] = 3.;
  1005.                 BP_std[index] = 3.;
  1006.                   }
  1007.                 lat = lat_min + (double)l*inc_lat + inc_lat/2.;
  1008.                 lon = lon_min + (double)L*inc_lon + inc_lon/2.;
  1009.                 if (lon >= 360.)
  1010.                   lon -= 360.;
  1011.                 alt = alt_min + (double)A*inc_alt + inc_alt/2.;
  1013.                 fprintf(fout, WRITE_bin, dday, lon, lat, alt,
  1014.                     BR_max[index], BT_max[index], BP_max[index],
  1015.                     NPT[index],
  1016.                     BR_std[index], BT_std[index], BP_std[index]);
  1017.               }
  1018.               }
  1019.           }
  1020.           }
  1023.         for (l = 0; l < npt_lat; l++)
  1024.           {
  1025.         for (L = 0 ; L < npt_lon ; L++)
  1026.           {
  1027.             index = l * npt_lon + L;
  1028.             if (NPT[index] > 0)
  1029.               {
  1030.             filled_bin ++;
  1031.             if (NPT[index] > 2)
  1032.               {
  1033.                 filled_bin2 ++;
  1034.               }
  1035.             if (NPT[index] > 1)
  1036.               {
  1037.                 filled_bin1 ++;
  1038.               }
  1039.               }
  1040.           }
  1041.           }
  1043.         for (l = 0; l < npt_lat; l++)
  1044.           {
  1045.         for (L = 0 ; L < npt_lon ; L++)
  1046.           {
  1047.             index = l * npt_lon + L;
  1048.             if (NPT[index] > 1)
  1049.               {
  1050.             lat = lat_min + (double)l*inc_lat + inc_lat/2.;
  1051.             lon = lon_min + (double)L*inc_lon + inc_lon/2.;
  1052.             if (lon >= 360.)
  1053.               lon -= 360.;
  1054.             fprintf(fout, "%7.3lf %7.3lf", lon, lat);
  1055.             for (i=0;i<NPT[index]; i++)
  1056.               {
  1057.                 fprintf(fout, " %7.3lf", alt_var[index][i]);
  1058.               }
  1059.             fprintf(fout, "\n" );
  1060.               }
  1061.           }
  1062.           }
  1063.       }
  1065.     fclose(fout);
  1067.     fprintf(stdout, "\tNombre de donnees lues      : %10d\n", data_in);
  1068.     fprintf(stdout, "\tNombre de donnees utilisees : %10d\n", data_out);
  1069.     fprintf(stdout, "\tNombre de bin remplis      : %10d\n", filled_bin);
  1070.     fprintf(stdout, "\tNombre de bin remplis (N>1) : %10d\n", filled_bin1);
  1071.     fprintf(stdout, "\tNombre de bin remplis (N>2) : %10d\n", filled_bin2);
  1072.       }



un exemple de mon fichier X
JOUR lat lon alt br bt bp
2032.376403461 -10.894 129.987 383.150 -0.343 2.969 -0.746

Voila je vous remercie de votre aide eventuelle


Aller à :