Changeset 7548


Ignore:
Timestamp:
Oct 16, 2009, 11:24:26 AM (13 years ago)
Author:
nariman
Message:

fixed memory leak in read_mux2

File:
1 edited

Legend:

Unmodified
Added
Removed
  • anuga_core/source/anuga/shallow_water/urs_ext.c

    r7276 r7548  
    3434
    3535
    36  */
     36*/
    3737
    3838
     
    4242void fillDataArray(int ista, int total_number_of_stations, int nt, int ig, int *nst,
    4343                   int *nft, float *data, int *istart_p,
    44                    int *istop_p, float *muxData)
     44                   int *istop_p, float *muxData)
    4545{
    4646    int it, last_it, jsta;
     
    6464        }
    6565    }
    66    
     66
    6767    if (nft[ista] != -1)
    6868    {
     
    7676        }
    7777    }     
    78    
     78
    7979    if (ig == -1 || nst[ista] == -1) /* currently ig==-1 => nst[ista]==-1 */
    8080    {
     
    103103                /* gauge is recording at this time */
    104104                memcpy(data + it, muxData + offset, sizeof(float));
    105                
    106                 //printf("%d: muxdata=%f\n", it, muxData[offset]);
    107                 //printf("data[%d]=%f, offset=%d\n", it, data[it], offset);
     105
     106                //printf("%d: muxdata=%f\n", it, muxData[offset]);
     107                //printf("data[%d]=%f, offset=%d\n", it, data[it], offset);
    108108                offset++;
    109109            }
     
    139139    if(x < NODATA + EPSILON && NODATA < x + EPSILON)
    140140    {
    141       return 0;
     141        return 0;
    142142    }
    143143    else
    144144    {
    145       return 1; 
     145        return 1; 
    146146    }
    147147}
     
    161161            numData += *(lros + ista) - *(fros + ista) + 1;
    162162            last_output_step = (last_output_step < *(lros+ista) ?
    163                             *(lros+ista):last_output_step);
     163                *(lros+ista):last_output_step);
    164164        }   
    165165        numData += last_output_step*total_number_of_stations; /* these are the t records */
     
    170170//Internal Functions
    171171int _read_mux2_headers(int numSrc,
    172                        char **muxFileNameArray,
    173                        int* total_number_of_stations,
    174                        int* number_of_time_steps,
    175                        double* delta_t,
    176                        //long* numDataMax,
    177                        int verbose)
     172                       char **muxFileNameArray,
     173                       int* total_number_of_stations,
     174                       int* number_of_time_steps,
     175                       double* delta_t,
     176                       //long* numDataMax,
     177                       int verbose)
    178178{
    179179    FILE *fp;
     
    194194        muxFileName = muxFileNameArray[i];
    195195        if(!susMuxFileName && strcmp(muxFileName + strlen(muxFileName) - 4,
    196                      "mux2") != 0)
     196            "mux2") != 0)
    197197        {
    198198            susMuxFileName = 1;
     
    228228            return -1; 
    229229        }
    230        
     230
    231231        if (!i)
    232232        {
    233233            elements_read = fread(total_number_of_stations, sizeof(int), 1, fp);
    234             if ((int) elements_read == 0 && ferror(fp)){
    235               fprintf(stderr, "Error reading total number of stations\n");
    236               return -2;
    237             }
    238        
     234            if ((int) elements_read == 0 && ferror(fp)){
     235                fprintf(stderr, "Error reading total number of stations\n");
     236                fclose(fp);
     237                return -2;
     238            }
     239
    239240            fros = (int*) malloc(*total_number_of_stations*numSrc*sizeof(int));
    240241            lros = (int*) malloc(*total_number_of_stations*numSrc*sizeof(int));
    241      
     242
    242243            mytgs0 = (struct tgsrwg*) malloc(*total_number_of_stations*sizeof(struct tgsrwg));
    243244            mytgs = (struct tgsrwg*) malloc(*total_number_of_stations*sizeof(struct tgsrwg));
    244245
    245             block_size = *total_number_of_stations*sizeof(struct tgsrwg);
     246            block_size = *total_number_of_stations*sizeof(struct tgsrwg);
    246247            elements_read = fread(mytgs0, block_size , 1, fp);
    247             if ((int) elements_read == 0 && ferror(fp)){
    248               fprintf(stderr, "Error reading mytgs0\n");
    249               return -2;
    250             }
     248            if ((int) elements_read == 0 && ferror(fp)){
     249                fprintf(stderr, "Error reading mytgs0\n");
     250                fclose(fp);
     251                return -2;
     252            }
    251253        }
    252254        else
    253255        {
    254             // Check that the mux files are compatible
     256            // Check that the mux files are compatible
    255257            elements_read = fread(&numsta, sizeof(int), 1, fp);
    256             if ((int) elements_read == 0 && ferror(fp)){
    257               fprintf(stderr, "Error reading numsta\n");
    258               return -2;
    259             }
    260            
     258            if ((int) elements_read == 0 && ferror(fp)){
     259                fprintf(stderr, "Error reading numsta\n");
     260                fclose(fp);
     261                return -2;
     262            }
     263
    261264            if(numsta != *total_number_of_stations)
    262265            {
    263266                fprintf(stderr,"%s has different number of stations to %s\n",
    264                 muxFileName,
    265                 muxFileNameArray[0]);
     267                    muxFileName,
     268                    muxFileNameArray[0]);
    266269                fclose(fp);
    267270                return -1;   
    268271            }
    269272
    270             block_size = numsta*sizeof(struct tgsrwg);
     273            block_size = numsta*sizeof(struct tgsrwg);
    271274            elements_read = fread(mytgs, block_size, 1, fp);
    272             if ((int) elements_read == 0 && ferror(fp)){
    273               fprintf(stderr, "Error reading mgtgs\n");
    274               return -2;
    275             }       
    276            
    277            
     275            if ((int) elements_read == 0 && ferror(fp)){
     276                fprintf(stderr, "Error reading mgtgs\n");
     277                fclose(fp);
     278                return -2;
     279            }       
     280
     281
    278282            for (j = 0; j < numsta; j++)
    279283            {
     
    281285                {
    282286                    fprintf(stderr, "%s has different sampling rate to %s\n",
    283                     muxFileName,
    284                     muxFileNameArray[0]);
     287                        muxFileName,
     288                        muxFileNameArray[0]);
    285289                    fclose(fp);
    286290                    return -1;           
     
    289293                {
    290294                    fprintf(stderr, "%s has different series length to %s\n",
    291                     muxFileName,
    292                     muxFileNameArray[0]);
     295                        muxFileName,
     296                        muxFileNameArray[0]);
    293297                    fclose(fp);
    294298                    return -1;           
     
    304308        /* Read the start and stop times for this source */
    305309        elements_read = fread(fros + i*(*total_number_of_stations),
    306                               *total_number_of_stations*sizeof(int), 1, fp);
    307         if ((int) elements_read == 0 && ferror(fp)){
    308           fprintf(stderr, "Error reading start times\n");
    309           return -3;
    310         }           
    311                            
    312                            
     310            *total_number_of_stations*sizeof(int), 1, fp);
     311        if ((int) elements_read == 0 && ferror(fp)){
     312            fprintf(stderr, "Error reading start times\n");
     313            fclose(fp);
     314            return -3;
     315        }           
     316
     317
    313318        elements_read = fread(lros + i*(*total_number_of_stations),
    314                               *total_number_of_stations*sizeof(int), 1, fp);
    315         if ((int) elements_read == 0 && ferror(fp)){
    316           fprintf(stderr, "Error reading stop times\n");       
    317           return -3;
    318         }                     
     319            *total_number_of_stations*sizeof(int), 1, fp);
     320        if ((int) elements_read == 0 && ferror(fp)){
     321            fprintf(stderr, "Error reading stop times\n");
     322            fclose(fp);
     323            return -3;
     324        }                     
    319325
    320326        /* Compute the size of the data block for this source */
    321327        numData = getNumData(fros + i*(*total_number_of_stations),
    322                              lros + i*(*total_number_of_stations),
    323                              (*total_number_of_stations));
     328            lros + i*(*total_number_of_stations),
     329            (*total_number_of_stations));
    324330
    325331        /* Sanity check */
     
    338344    }
    339345
    340    
     346
    341347    // Store time resolution and number of timesteps   
    342348    // These are the same for all stations as tested above, so
     
    366372    float *muxData=NULL; // Suppress warning
    367373    long numData;
     374    long *perm = NULL;
     375    long *permutation_temp = NULL;
    368376
    369377    int len_sts_data, error_code;
     
    375383    int number_of_time_steps, N;
    376384    double delta_t;
    377    
     385
    378386    size_t elements_read;
    379    
     387
    380388    // Shorthands pointing to memory blocks for each source
    381389    int *fros_per_source=NULL;     
    382390    int *lros_per_source=NULL;         
    383391
    384    
     392
    385393    error_code = _read_mux2_headers(numSrc,
    386                                     muxFileNameArray,
    387                                     &total_number_of_stations,
    388                                     &number_of_time_steps,
    389                                     &delta_t,
    390                                     verbose);
     394        muxFileNameArray,
     395        &total_number_of_stations,
     396        &number_of_time_steps,
     397        &delta_t,
     398        verbose);
    391399    if (error_code != 0) {
    392       printf("urs_ext.c: Internal function _read_mux2_headers failed: Error code = %d\n",
    393              error_code);
    394      
    395       return NULL;
    396     }
    397    
     400        printf("urs_ext.c: Internal function _read_mux2_headers failed: Error code = %d\n",
     401            error_code);
     402
     403        return NULL;
     404    }
     405
    398406
    399407    // Apply rule that an empty permutation file means 'take all stations'
     
    404412    {
    405413        number_of_selected_stations = total_number_of_stations; 
    406    
     414
    407415        // Return possibly updated number of stations
    408416        *number_of_stations = total_number_of_stations;     
    409      
     417
    410418        // Create the Identity permutation vector
    411         permutation = (long *) malloc(number_of_selected_stations*sizeof(long));
     419        permutation_temp = (long *) malloc(number_of_selected_stations*sizeof(long));
     420        if (permutation_temp == NULL)
     421        {
     422            printf("ERROR: Memory for permutation_temp could not be allocated.\n");
     423            return NULL;
     424        }
     425       
    412426        for (i = 0; i < number_of_selected_stations; i++)
    413427        {
    414             permutation[i] = (long) i; 
    415         }
    416     }
    417    
     428            permutation_temp[i] = (long) i; 
     429        }
     430
     431        perm = permutation_temp;
     432    }
     433    else
     434    {
     435        perm = permutation;
     436    }
     437
    418438    // The params array is used only for passing data back to Python.
    419439    params[0] = (double) number_of_selected_stations;
    420440    params[1] = (double) delta_t;
    421441    params[2] = (double) number_of_time_steps;
    422    
    423    
    424    
     442
    425443    // Make array(s) to hold demuxed data for stations given in the
    426444    // permutation file
     
    446464
    447465    temp_sts_data = (float*) calloc(len_sts_data, sizeof(float));
     466    if (temp_sts_data == NULL)
     467    {
     468        printf("ERROR: Memory for temp_sts_data could not be allocated.\n");
     469        return NULL;
     470    }
    448471
    449472    muxData = (float*) calloc(numDataMax, sizeof(float));
    450    
     473    if (temp_sts_data == NULL)
     474    {
     475        printf("ERROR: Memory for muxData could not be allocated.\n");
     476        return NULL;
     477    }
     478
    451479    // Loop over all sources
    452480    for (isrc = 0; isrc < numSrc; isrc++)
    453481    {
    454    
     482
    455483        // Shorthands to local memory
    456484        fros_per_source = (int*) fros + isrc*total_number_of_stations;
    457485        lros_per_source = (int*) lros + isrc*total_number_of_stations;     
    458            
    459    
     486
     487
    460488        // Read in data block from mux2 file
    461489        muxFileName = muxFileNameArray[isrc];
     
    463491        {
    464492            fprintf(stderr, "cannot open file %s\n", muxFileName);
     493            free(muxData);
     494            free(temp_sts_data);
     495            free(muxData);
     496
    465497            return NULL;                   
    466498        }
     
    472504        offset = (long int)sizeof(int) + total_number_of_stations*(sizeof(struct tgsrwg) + 2*sizeof(int));
    473505        //printf("\n offset %i ", (long int)offset);
    474         fseek(fp, offset, 0);
     506        fseek(fp, offset, 0);
    475507
    476508        numData = getNumData(fros_per_source,
    477                              lros_per_source,
    478                              total_number_of_stations);
    479         // Note numData is larger than what it has to be.                   
     509            lros_per_source,
     510            total_number_of_stations);
     511        // Note numData is larger than what it has to be.                   
    480512        //elements_read = fread(muxData, ((int) numData)*sizeof(float), 1, fp);
    481513        elements_read = fread(muxData, (size_t) sizeof(float), (size_t) numData, fp);
    482         //printf("\n elements_read  %d, ", (int)elements_read);
    483         //printf("\n ferror(fp)  %d, ", (int)ferror(fp));
    484         if ((int) elements_read == 0 && ferror(fp)) {
    485           fprintf(stderr, "Error reading mux data\n");
    486           return NULL;
    487         }       
    488        
     514        //printf("\n elements_read  %d, ", (int)elements_read);
     515        //printf("\n ferror(fp)  %d, ", (int)ferror(fp));
     516        if ((int) elements_read == 0 && ferror(fp)) {
     517            fprintf(stderr, "Error reading mux data\n");
     518            fclose(fp);
     519            free(muxData);
     520            free(temp_sts_data);
     521            free(muxData);
     522
     523            return NULL;
     524        }       
     525
    489526        fclose(fp); 
    490        
     527
    491528        // loop over stations present in the permutation array
    492529        //     use ista with mux data
     
    494531        for(i = 0; i < number_of_selected_stations; i++)
    495532        {               
    496    
    497             ista = (int) permutation[i]; // Get global index into mux data 
    498        
     533
     534            ista = (int) perm[i]; // Get global index into mux data 
     535
    499536            // fill the data0 array from the mux file, and weight it
    500537            fillDataArray(ista,
    501                           total_number_of_stations,
    502                           number_of_time_steps,
    503                           mytgs0[ista].ig, // Grid number (if -1 fill with zeros)
    504                           fros_per_source,
    505                           lros_per_source,
    506                           temp_sts_data,
    507                           &istart,
    508                           &istop,
    509                           muxData);
     538                total_number_of_stations,
     539                number_of_time_steps,
     540                mytgs0[ista].ig, // Grid number (if -1 fill with zeros)
     541                fros_per_source,
     542                lros_per_source,
     543                temp_sts_data,
     544                &istart,
     545                &istop,
     546                muxData);
    510547
    511548            // Weight appropriately and add
     
    520557                    sts_data[i][k] = NODATA;
    521558                }
    522                 //printf("%d: temp_sts_data[%d]=%f\n", i, k, temp_sts_data[k]);     
    523            
     559                //printf("%d: temp_sts_data[%d]=%f\n", i, k, temp_sts_data[k]);     
     560
    524561            }
    525            
    526            
    527             // Update metadata (e.g. start time and end time)
    528             N = number_of_time_steps;
    529            
    530             if (isrc == 0) {
    531                 // Assign values for first source
    532                 sts_data[i][N] = (float)mytgs0[ista].geolat;
    533                 sts_data[i][N+1] = (float)mytgs0[ista].geolon;
    534                 sts_data[i][N+2] = (float)mytgs0[ista].z;
    535                 sts_data[i][N+3] = (float)fros_per_source[ista];
    536                 sts_data[i][N+4] = (float)lros_per_source[ista];
    537             } else {
    538                 // Update first and last timesteps for subsequent sources
    539                 if (sts_data[i][N+3] > (float)fros_per_source[ista]) {         
    540                     if (verbose) {
    541                         printf("Adjusting start time for station %d and source %d",
    542                                ista, isrc);
    543                         printf(" from %f to %f\n",
    544                                sts_data[i][N+3],
    545                                (float) fros_per_source[ista]); 
    546                     }
    547                     sts_data[i][N+3] = (float) fros_per_source[ista];
    548                 }
    549                
    550                 if (sts_data[i][N+4] < (float) lros_per_source[ista]) {         
    551                     if (verbose) {
    552                         printf("Adjusting end time for station %d and source %d",
    553                                ista, isrc);
    554                         printf(" from %f to %f\n",
    555                                sts_data[i][N+4],
    556                                (float) lros_per_source[ista]); 
    557                     }
    558                     sts_data[i][N+4] = (float) lros_per_source[ista];
    559                 }               
    560             }
     562
     563
     564            // Update metadata (e.g. start time and end time)
     565            N = number_of_time_steps;
     566
     567            if (isrc == 0) {
     568                // Assign values for first source
     569                sts_data[i][N] = (float)mytgs0[ista].geolat;
     570                sts_data[i][N+1] = (float)mytgs0[ista].geolon;
     571                sts_data[i][N+2] = (float)mytgs0[ista].z;
     572                sts_data[i][N+3] = (float)fros_per_source[ista];
     573                sts_data[i][N+4] = (float)lros_per_source[ista];
     574            } else {
     575                // Update first and last timesteps for subsequent sources
     576                if (sts_data[i][N+3] > (float)fros_per_source[ista]) {         
     577                    if (verbose) {
     578                        printf("Adjusting start time for station %d and source %d",
     579                            ista, isrc);
     580                        printf(" from %f to %f\n",
     581                            sts_data[i][N+3],
     582                            (float) fros_per_source[ista]); 
     583                    }
     584                    sts_data[i][N+3] = (float) fros_per_source[ista];
     585                }
     586
     587                if (sts_data[i][N+4] < (float) lros_per_source[ista]) {         
     588                    if (verbose) {
     589                        printf("Adjusting end time for station %d and source %d",
     590                            ista, isrc);
     591                        printf(" from %f to %f\n",
     592                            sts_data[i][N+4],
     593                            (float) lros_per_source[ista]); 
     594                    }
     595                    sts_data[i][N+4] = (float) lros_per_source[ista];
     596                }               
     597            }
    561598        }
    562599    }
    563600
    564601    //printf("sts_data[1,8]=%f\n", sts_data[1][8]);
    565    
     602
    566603    free(muxData);
    567604    free(temp_sts_data);
     
    570607    free(mytgs0);
    571608
     609    if (permutation_temp)
     610    {
     611        free(permutation_temp);
     612    }
     613
    572614    return sts_data;
    573615}
     
    585627    A Python int is equivalent to a C long
    586628    (this becomes really important on 64 bit architectures)
    587    
     629
    588630    A Python double corresponds to a C double
    589631    */
    590    
     632
    591633    PyObject *filenames;
    592634    PyArrayObject *pyweights;
     
    613655    int time;
    614656    int num_ts;
    615    
     657
    616658    // Convert Python arguments to C
    617659    if (!PyArg_ParseTuple(args, "iOOOOi",
    618               &numSrc, &filenames, &pyweights, &file_params,
    619               &permutation, &verbose))
    620     {
    621             PyErr_SetString(PyExc_RuntimeError,
    622                 "Input arguments to read_mux2 failed");
    623             return NULL;
     660        &numSrc, &filenames, &pyweights, &file_params,
     661        &permutation, &verbose))
     662    {
     663        PyErr_SetString(PyExc_RuntimeError,
     664            "Input arguments to read_mux2 failed");
     665        return NULL;
    624666    }
    625667
     
    654696    {
    655697        PyErr_SetString(PyExc_ValueError,
    656                         "ERROR: Memory for muxFileNameArray could not be allocated.");
     698            "ERROR: Memory for muxFileNameArray could not be allocated.");
     699
    657700        return NULL;
    658701    }
     
    665708        {
    666709            PyErr_SetString(PyExc_ValueError, "filename not a string");
     710            free(muxFileNameArray);
     711
    667712            return NULL;
    668713        }       
     
    672717        {
    673718            PyErr_SetString(PyExc_ValueError,
    674           "ERROR: Memory for muxFileNameArray could not be allocated.\n");
     719                "ERROR: Memory for muxFileNameArray could not be allocated.\n");
     720            free(muxFileNameArray);
     721
    675722            return NULL;
    676723        }
     
    680727    {
    681728        PyErr_SetString(PyExc_ValueError,
    682           "file_params must be one-dimensional and of type double");
     729            "file_params must be one-dimensional and of type double");
     730        free(muxFileNameArray);
     731
    683732        return NULL;
    684733    }
     
    687736    // Create array for weights which are passed to read_mux2
    688737    weights = (float*) malloc(numSrc*sizeof(float));
     738    if (weights == NULL)
     739    {
     740        PyErr_SetString(PyExc_ValueError,
     741            "ERROR: Memory for weights could not be allocated.");
     742        free(muxFileNameArray);
     743        return NULL;
     744    }
     745
     746
    689747    for (i = 0; i < numSrc; i++)
    690748    {
    691749        weights[i] = (float)(*(double*)(pyweights->data + i*pyweights->strides[0]));
    692750    }
    693    
     751
    694752    // Desired number of stations
    695753    number_of_selected_stations = (int) permutation->dimensions[0];
     
    697755    // Read in mux2 data from file
    698756    cdata = _read_mux2(numSrc,
    699                        muxFileNameArray,
    700                        weights,
    701                        (double*)file_params->data,
    702                        &number_of_selected_stations,
    703                        (long*) permutation->data,
    704                        verbose);
     757        muxFileNameArray,
     758        weights,
     759        (double*)file_params->data,
     760        &number_of_selected_stations,
     761        (long*) permutation->data,
     762        verbose);
    705763
    706764    if (!cdata)
    707765    {
    708         PyErr_SetString(PyExc_ValueError, "No STS_DATA returned");
     766        PyErr_SetString(PyExc_RuntimeError, "No STS_DATA returned");
    709767        return NULL;
    710768    }       
    711                
    712                
    713     // Allocate space for return vector
    714     total_number_of_stations = (int)*(double*)(file_params->data + 0*file_params->strides[0]);
     769
     770    //Extracting data
     771    total_number_of_stations = (int)*((double*)(file_params->data + 0*file_params->strides[0]));
    715772    dt = *(double*)(file_params->data + 1*file_params->strides[0]);
    716773    nt = (int)*(double*)(file_params->data + 2*file_params->strides[0]);
    717774
    718    
     775
    719776    // Find min and max start times of all gauges
    720777    start_tstep = nt + 1;
     
    724781        //printf("cdata[%d] start = %f\n", i, (double) cdata[i][nt+3]);
    725782        // printf("cdata[%d] finish = %f\n", i, (double) cdata[i][nt+4]);   
    726    
     783
    727784        if ((int)cdata[i][nt + 3] < start_tstep)
    728785        {
     
    739796        printf("ERROR: Gauge data has incorrect start and finish times:\n");
    740797        printf("   start_tstep = %d, max_number_of_steps = %d\n",
    741                start_tstep, nt);
     798            start_tstep, nt);
    742799        printf("   finish_tstep = %d, min_number_of_steps = %d\n",
    743                finish_tstep, 0);   
    744            
     800            finish_tstep, 0);   
     801
    745802        PyErr_SetString(PyExc_ValueError, "Incorrect start and finish times"); 
     803
     804        free(weights);
     805        free(muxFileNameArray);
     806        for (i = 0; i < number_of_selected_stations; ++i)
     807        {
     808            free(cdata[i]);
     809        }
     810        free(cdata);
     811
    746812        return NULL;
    747813    }
     
    750816    {
    751817        PyErr_SetString(PyExc_ValueError,
    752                     "ERROR: Gauge data has non-postive_length");
     818            "ERROR: Gauge data has non-postive_length");
     819        free(weights);
     820        free(muxFileNameArray);
     821        for (i = 0; i < number_of_selected_stations; ++i)
     822        {
     823            free(cdata[i]);
     824        }
     825        free(cdata);
     826
    753827        return NULL;
    754828    }
     
    757831    dimensions[0] = number_of_selected_stations;
    758832    dimensions[1] = num_ts + POFFSET;
    759    
     833
    760834    pydata = (PyArrayObject*) anuga_FromDims(2, dimensions, PyArray_DOUBLE);
    761835    if(pydata == NULL)
    762836    {
    763         PyErr_SetString(PyExc_ValueError,
    764           "ERROR: Memory for pydata array could not be allocated.");
    765         return NULL;
    766     }
    767 
    768    
     837        PyErr_SetString(PyExc_RuntimeError,
     838            "ERROR: Memory for pydata array could not be allocated.");
     839        free(weights);
     840        free(muxFileNameArray);
     841        for (i = 0; i < number_of_selected_stations; ++i)
     842        {
     843            free(cdata[i]);
     844        }
     845        free(cdata);
     846
     847        return NULL;
     848    }
     849
     850
    769851    // Each gauge begins and ends recording at different times. When a gauge is
    770852    // not recording but at least one other gauge is.
     
    783865                    // still recording
    784866                    *(double*)(pydata->data + i*pydata->strides[0]
    785                                + time*pydata->strides[1]) =
    786                       0.0;
     867                    + time*pydata->strides[1]) =
     868                        0.0;
    787869                }
    788870                else
    789871                {
    790                   //printf("cdata[%d][%d] = %f\n", i, it, cdata[i][it]);
    791                
     872                    //printf("cdata[%d][%d] = %f\n", i, it, cdata[i][it]);
     873
    792874                    *(double*)(pydata->data + i*pydata->strides[0]
    793                                     + time*pydata->strides[1]) =
     875                    + time*pydata->strides[1]) =
    794876                        cdata[i][it];
    795877                }
     
    799881        // Pass back lat,lon,elevation
    800882        for (j = 0; j < POFFSET; j++)
    801         {
    802           *(double*)(pydata->data + i*pydata->strides[0]
    803                      + (num_ts + j)*pydata->strides[1]) =
    804             cdata[i][nt + j];
     883        {
     884            *(double*)(pydata->data + i*pydata->strides[0]
     885            + (num_ts + j)*pydata->strides[1]) =
     886                cdata[i][nt + j];
    805887        }
    806888    }
    807889
    808890    free(weights);
    809    
     891
    810892    // Free filename array, but not independent Python strings
    811893    // FIXME(Ole): Do we need to update a reference counter in this case?
    812894    free(muxFileNameArray);
    813    
     895
    814896    for (i = 0; i < number_of_selected_stations; ++i)
    815897    {
Note: See TracChangeset for help on using the changeset viewer.