surfDepValues *determineSurfaceDepthsBasin(globalBasinData *basinData ,gridStruct *location, char *fileName, int basinNum, int surfNum)
/*
 Purpose:   obtain the depths for all lat lon points within the  for a given surface file
 
 Input variables:
 location  - structure containing lat lon grid
 fileName  - filename of the surface file for reading
 
 Output variables:
 surfDep   - (malloc'd) pointer to structure containing surface depths for all lat lon points
 */
{
    // read in the filename
    surfRead *currentSurface;
    currentSurface = loadSurface(fileName);
    
    surfDepValues *surfDep;
    surfDep = malloc(sizeof(surfDepValues));
    adjacentPointsStruct *points;
    
    // loop over values and find the depth of the surface at all points (2D interpolation)
    for(int i = 0; i < location->nX; i++)
    {
        for(int j = 0; j < location->nY; j++)
        {
            if(basinData->inBasinLatLon[basinNum][basinData->boundaryType[basinNum][surfNum]][i][j] == 1)
            {
                // find adjacent points
                points = findAdjacentPoints(currentSurface, location->Lat[i][j], location->Lon[i][j]);
                //                printf("%lf %lf\n",location->Lat[i][j], location->Lon[i][j]);
                //                printf("%i\n",basinData->inBasinLatLon[basinNum][basinData->boundaryType[basinNum][surfNum]][i][j]);
                
                if (points->inSurfaceBounds == 1)
                {
                    // interpolate
                    surfDep->dep[i][j] = biLinearInterpolation( currentSurface->loni[points->lonInd[0]], currentSurface->loni[points->lonInd[1]], currentSurface->lati[points->latInd[0]], currentSurface->lati[points->latInd[1]], currentSurface->raster[points->lonInd[0]][points->latInd[0]], currentSurface->raster[points->lonInd[0]][points->latInd[1]], currentSurface->raster[points->lonInd[1]][points->latInd[0]], currentSurface->raster[points->lonInd[1]][points->latInd[1]], location->Lon[i][j], location->Lat[i][j]);
                    free(points);
                }
                else
                {
                    printf("%lf %lf\n",location->Lat[i][j], location->Lon[i][j]);

                    printf("Error, point lies outside basin surface domain.\n");
                }
            }
            else
            {
                surfDep->dep[i][j] = NAN; // define as NAN if surface is outside of the boundary
            }
        }
    }
    free(currentSurface);
    
    return surfDep;
}
예제 #2
0
TEST(stencil, biLinearInterpolationTest) {
  ASSERT_EQ(1.0, biLinearInterpolation(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0));

  // CORNERS
  ASSERT_EQ(1.0, biLinearInterpolation(0.0, 1.0, 0.0, 1.0, 1.0, 2.0, 3.0, 4.0));

  ASSERT_EQ(2.0, biLinearInterpolation(1.0, 0.0, 0.0, 1.0, 1.0, 2.0, 3.0, 4.0));

  ASSERT_EQ(3.0, biLinearInterpolation(1.0, 0.0, 1.0, 0.0, 1.0, 2.0, 3.0, 4.0));

  ASSERT_EQ(4.0, biLinearInterpolation(0.0, 1.0, 1.0, 0.0, 1.0, 2.0, 3.0, 4.0));

  // CENTER OF EDGES
  ASSERT_EQ(1.5, biLinearInterpolation(1.0, 1.0, 0.0, 1.0, 1.0, 2.0, 3.0, 4.0));

  ASSERT_EQ(2.5, biLinearInterpolation(1.0, 0.0, 1.0, 1.0, 1.0, 2.0, 3.0, 4.0));

  ASSERT_EQ(3.5, biLinearInterpolation(1.0, 1.0, 1.0, 0.0, 1.0, 2.0, 3.0, 4.0));

  ASSERT_EQ(2.5, biLinearInterpolation(0.0, 1.0, 1.0, 1.0, 1.0, 2.0, 3.0, 4.0));

  // CENTRE
  ASSERT_EQ(2.5, biLinearInterpolation(1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 3.0, 4.0));
}
예제 #3
0
void extractSlice(gridStruct *location, modOrigin modelOrigin, sliceExtent sliceBounds, globalDataValues *globDataVals, char *outputDirectory, int sliceNumber)
{
    
    sliceExtractData *sliceData;
    sliceData = malloc(sizeof(sliceExtractData));
    generateSliceXYpoints(sliceData, modelOrigin, sliceBounds);

    
    // loop over points
    int xInd = 0;
    int yInd = 0;
    double X1, X2, Y1, Y2;
    double Q11Vp, Q12Vp, Q21Vp, Q22Vp;
    double Q11Vs, Q12Vs, Q21Vs, Q22Vs;
    double Q11Rho, Q12Rho, Q21Rho, Q22Rho;
    
    for(int i = 0; i < sliceData->nPts; i++)
    {
        // if x or y value is outside of the bound of the dataset return NaNs.
//        printf("%lf %lf %lf\n", sliceData->xPts[i], location->X[0],location->X[location->nX-1]);
//        printf("%lf %lf %lf\n", sliceData->yPts[i], location->Y[0],location->Y[location->nY-1]);

        if(sliceData->xPts[i]<location->X[0] || sliceData->xPts[i]>location->X[location->nX-1] || sliceData->yPts[i]>location->Y[location->nY-1] || sliceData->yPts[i]<location->Y[0] )
        {
            for(int k = 0; k < location->nZ; k++)
            {
                sliceData->Vp[i][k] = NAN;
                sliceData->Vs[i][k] = NAN;
                sliceData->Rho[i][k] = NAN;
            }
        }
        else  // get indice of nearby points
        {
            for(int k = 0; k < location->nX; k++)
            {
                if(location->X[k]>=sliceData->xPts[i])
                {
                    xInd = k-1;
                    break;
                }
            }
            for(int j = 0; j < location->nY; j++)
            {
                if(location->Y[j]>=sliceData->yPts[i])
                {
                    yInd = j-1;
                    break;
                }
            }
            // interpolate points
            X1 = location->X[xInd];
            X2 = location->X[xInd+1];
            Y1 = location->Y[yInd];
            Y2 = location->Y[yInd+1];
            
//            double lat1, lat2, lon1, lon2;
//            lat1 = location->Lat[xInd][yInd];
//            lat2 = location->Lat[xInd+1][yInd+1];
//            lon1 = location->Lon[xInd][yInd];
//            lon2 = location->Lon[xInd+1][yInd+1];
//            
//            printf("%lf %lf %lf %lf\n", X1, X2, Y1,Y2);
//            printf("%lf %lf\n",sliceData->xPts[i], sliceData->yPts[i]);
//            printf("%lf %lf %lf %lf\n", lat1, lat2, lon1, lon2);
//            printf("%lf %lf\n",sliceData->latPts[i], sliceData->lonPts[i]);
            
            for(int k = 0; k < location->nZ; k++)
            {
                // Vs
                Q11Vs = globDataVals->Vs[xInd][yInd][k];
                Q12Vs = globDataVals->Vs[xInd][yInd+1][k];
                Q21Vs = globDataVals->Vs[xInd+1][yInd][k];
                Q22Vs = globDataVals->Vs[xInd+1][yInd+1][k];
                
//                printf("%lf %lf %lf %lf\n", Q11Vs, Q21Vs, Q22Vs, Q12Vs);
                
                sliceData->Vs[i][k] = biLinearInterpolation(X1, X2, Y1, Y2, Q11Vs, Q12Vs, Q21Vs, Q22Vs, sliceData->xPts[i], sliceData->yPts[i]);
                
                // Vp
                Q11Vp = globDataVals->Vp[xInd][yInd][k];
                Q12Vp = globDataVals->Vp[xInd][yInd+1][k];
                Q21Vp = globDataVals->Vp[xInd+1][yInd][k];
                Q22Vp = globDataVals->Vp[xInd+1][yInd+1][k];
//                printf("%lf %lf %lf %lf\n", Q11Vp, Q21Vp, Q22Vp, Q12Vp);

                
                sliceData->Vp[i][k] = biLinearInterpolation(X1, X2, Y1, Y2, Q11Vp, Q12Vp, Q21Vp, Q22Vp, sliceData->xPts[i], sliceData->yPts[i]);
                
                // Rho
                Q11Rho = globDataVals->Rho[xInd][yInd][k];
                Q12Rho = globDataVals->Rho[xInd][yInd+1][k];
                Q21Rho = globDataVals->Rho[xInd+1][yInd][k];
                Q22Rho = globDataVals->Rho[xInd+1][yInd+1][k];
                
                sliceData->Rho[i][k] = biLinearInterpolation(X1, X2, Y1, Y2, Q11Rho, Q12Rho, Q21Rho, Q22Rho, sliceData->xPts[i], sliceData->yPts[i]);
            }
        }
        
    }
    char sliceDir[128];
    sprintf(sliceDir,"%s/Slices",outputDirectory);

    struct stat st = {0};
    if (stat(sliceDir, &st) == -1)
    {
        // create output directory and the velocity model
        mkdir(sliceDir, 0700);
    }
    
    // generate file for writing
    FILE *fp2;
    double currRho, currVp, currVs;
    char fName[128];
    sprintf(fName,"%s/ExtractedSlice%i.txt",sliceDir,sliceNumber);
    fp2 = fopen(fName,"w");
    fprintf(fp2,"Extracted slice #%i.\n",sliceNumber);
    fprintf(fp2,"Slice_Horizontal_Resolution\t%i\n",sliceBounds.resXY);
    fprintf(fp2,"LatA:\t%lf\n",sliceData->latPts[0]);
    fprintf(fp2,"LatB:\t%lf\n",sliceData->latPts[sliceData->nPts-1]);
    fprintf(fp2,"LonA:\t%lf\n",sliceData->lonPts[0]);
    fprintf(fp2,"LonB:\t%lf\n",sliceData->lonPts[sliceData->nPts-1]);
    fprintf(fp2,"Lat \t Lon \t Depth \t Vp \t Vs \t Rho\n");
    for(int i = 0; i < sliceData->nPts; i++)
    {
        for(int m = 0; m < location->nZ; m++)
        {
            currVp = sliceData->Vp[i][m];
            currRho = sliceData->Rho[i][m];
            currVs = sliceData->Vs[i][m];
            fprintf(fp2, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",sliceData->latPts[i],sliceData->lonPts[i], location->Z[m], currVp, currVs, currRho);
            
        }
        
    }
    
    fclose(fp2);
    free(sliceData);
    
}
surfDepValues *determineSurfaceDepths(gridStruct *location, char *fileName)
/*
 Purpose:   obtain the depths for all lat lon points for a given surface file
 
 Input variables:
 location  - structure containing lat lon grid
 fileName  - filename of the surface file for reading
 
 Output variables:
 surfDep   - (malloc'd) pointer to structure containing surface depths for all lat lon points
 */
{
    // read in the filename
    surfRead *currentSurface;
    currentSurface = loadSurface(fileName);
    
    surfDepValues *surfDep;
    surfDep = malloc(sizeof(surfDepValues));
    adjacentPointsStruct *points;
    
    double p1, p2, p3, v1, v2;

    
    // loop over values and find the depth of the surface at all points (2D interpolation)
    for(int i = 0; i < location->nX; i++)
    {
        for(int j = 0; j < location->nY; j++)
        {
            // find adjacent points
            points = findAdjacentPoints(currentSurface, location->Lat[i][j], location->Lon[i][j]);
            
            if (points->inSurfaceBounds == 1)
            {
            // interpolate
            surfDep->dep[i][j] = biLinearInterpolation( currentSurface->loni[points->lonInd[0]], currentSurface->loni[points->lonInd[1]], currentSurface->lati[points->latInd[0]], currentSurface->lati[points->latInd[1]], currentSurface->raster[points->lonInd[0]][points->latInd[0]], currentSurface->raster[points->lonInd[0]][points->latInd[1]], currentSurface->raster[points->lonInd[1]][points->latInd[0]], currentSurface->raster[points->lonInd[1]][points->latInd[1]], location->Lon[i][j], location->Lat[i][j]);
            }
            else if (points->inLatExtensionZone == 1)
            {
                p1 = currentSurface->loni[points->lonInd[0]];
                p2 = currentSurface->loni[points->lonInd[1]];
                v1 = currentSurface->raster[points->lonInd[0]][points->latEdgeInd];
                v2 = currentSurface->raster[points->lonInd[1]][points->latEdgeInd];
                p3 = location->Lon[i][j];
                surfDep->dep[i][j] = linearInterpolation(p1, p2, v1, v2, p3);
            }
            else if (points->inLonExtensionZone == 1)
            {
                p1 = currentSurface->lati[points->latInd[0]];
                p2 = currentSurface->lati[points->latInd[1]];
                v1 = currentSurface->raster[points->lonEdgeInd][points->latInd[0]];
                v2 = currentSurface->raster[points->lonEdgeInd][points->latInd[1]];
                p3 = location->Lat[i][j];
                surfDep->dep[i][j] = linearInterpolation(p1, p2, v1, v2, p3);
            }
            else if (points->inCornerZone == 1)
            {
                surfDep->dep[i][j] = currentSurface->raster[points->cornerLonInd][points->cornerLatInd];
            }
            free(points);

        }
    }
    free(currentSurface);
        
    return surfDep;
}
예제 #5
0
depInterpVals *loadEPtomo2010subMod(gridStruct *location)
/*
 Purpose:   read in the Eberhart-Phillips 2010 tomography dataset
 
 Input variables:
 location       - struct containing the lat lon and dep points
 
 Output variables:
 surfDepVals    - (malloc'd) pointer to a struct containing the values of the "surfaces" at each lat lon value 
 
 */
{
    const char *varNames[3];
    varNames[0] = "vp", varNames[1] = "vs", varNames[2] = "rho";
    int nElev = 14; // only read first 14 for efficiency
    int elev[17] = {15, 1, -3, -8, -15, -23, -30, -38, -48, -65, -85, -105, -130, -155, -185, -225, -275 };
//    int elev[21] = {15, 1, -3, -5, -8, -11, -15, -23, -30, -38, -48, -65, -85, -105, -130, -155, -185, -225, -275, -370, -630};
    //int elev[20] = {10, 1, -5, -8, -11, -15, -23, -30, -38, -48, -65, -85, -105, -130, -155, -185, -225, -275, -370, -620};
    char baseFilename[256];
    
    depInterpVals *surfDepVals = NULL;
    surfDepVals = malloc(sizeof(depInterpVals));
    surfDepVals->numSurf = nElev;
    surfRead *tempSurf;
    adjacentPointsStruct *points;
    
    double X1, X2, Y1, Y2, Q11, Q12, Q22, Q21, X, Y, interpVal;


    for(int i = 0; i < nElev; i++)
    {
        surfDepVals->deps[i] = elev[i];
        for(int j = 0; j < 3; j++)
        {
            sprintf(baseFilename,"Data/Tomography/surf_tomography_%s_elev%i.in",varNames[j],elev[i]);
            // read the surface
            tempSurf = loadSurface(baseFilename);
            // write a surface vector (for IDW)
            for(int k = 0; k < location->nX; k++)
            {
                for(int n = 0; n < location->nY; n++)
                {
                    points = findAdjacentPoints(tempSurf, location->Lat[k][n], location->Lon[k][n]); // a little inefficient as process is repeated for each of Vp Vs and Rho!
                    X1 = tempSurf->loni[points->lonInd[0]];
                    X2 = tempSurf->loni[points->lonInd[1]];
                    Y1 = tempSurf->lati[points->latInd[0]];
                    Y2 = tempSurf->lati[points->latInd[1]];
                    X = location->Lon[k][n];
                    Y = location->Lat[k][n];
                    Q11 = tempSurf->raster[points->lonInd[0]][points->latInd[0]];
                    Q12 = tempSurf->raster[points->lonInd[0]][points->latInd[1]];
                    Q21 = tempSurf->raster[points->lonInd[1]][points->latInd[0]];
                    Q22 = tempSurf->raster[points->lonInd[1]][points->latInd[1]];
                    
                    interpVal = biLinearInterpolation(X1, X2, Y1, Y2, Q11, Q12, Q21, Q22, X, Y);
                    if(j == 0)
                    {
                        surfDepVals->Vp[i][k][n] = interpVal;
                    }
                    else if(j == 1)
                    {
                        surfDepVals->Vs[i][k][n] = interpVal;
                    }
                    else if(j ==2)
                    {
                        surfDepVals->Rho[i][k][n] = interpVal;
                    }
                    free(points);
                }
            }
            free(tempSurf);
        }
        printf("\rReading tomography data %d%% complete.", i*100/nElev);
        fflush(stdout);
    }
    printf("\rReading tomography data 100%% complete.");
    fflush(stdout);
    printf("\n");

return surfDepVals;

}