Пример #1
0
int main(int argc, char ** argv)
{
    char *etreefile;
    dbctl_t *myctl;
    etree_t *ep;

    /* read command line argument */
    if (argc != 2) {
        fprintf(stderr, "Usage: showdbctl etreename\n");
        exit(1);
    }

    etreefile = argv[1];

    if ((ep = etree_open(etreefile, O_RDONLY, 0, 0, 0)) == NULL) {
        fprintf(stderr, "Fail to open the etree\n");
        exit(1);
    }

    myctl = cvm_newdbctl();
    if (myctl == NULL) {
        perror("cvm_newdbctl");
        exit(1);
    }

    if ((myctl = cvm_getdbctl(ep)) == NULL) {
        fprintf(stderr, "Cannot get the material database control data\n");
        exit(1);
    }

    printf("\n");
    printf("create_db_name:               %s\n", ep->pathname);
    printf("create_model_name:            %s\n", myctl->create_model_name);
    printf("create_author:                %s\n", myctl->create_author);
    printf("create_date:                  %s\n", myctl->create_date);
    printf("create_field_count:           %s\n", myctl->create_field_count);
    printf("create_field_names:           %s\n", myctl->create_field_names);
    printf("\n");

    printf("region_origin_latitude_deg:   %f\n", 
           myctl->region_origin_latitude_deg);
    printf("region_origin_longitude_deg:  %f\n", 
           myctl->region_origin_longitude_deg);
    printf("region_length_east_m:         %f\n", myctl->region_length_east_m);
    printf("region_length_north_m:        %f\n", myctl->region_length_north_m);
    printf("region_depth_shallow_m:       %f\n", 
           myctl->region_depth_shallow_m);
    printf("region_depth_deep_m:          %f\n", myctl->region_depth_deep_m);
    printf("\n");

    printf("domain_endpoint_x:            %u\n", myctl->domain_endpoint_x);
    printf("domain_endpoint_y:            %u\n", myctl->domain_endpoint_y);
    printf("domain_endpoint_z:            %u\n", myctl->domain_endpoint_z);

    cvm_freedbctl(myctl);
    
    etree_close(ep);
    
    return 0;
}
Пример #2
0
int main(int argc, char **argv)
{
    etree_t *ep;
    etree_addr_t root;
    payload_t payload;
    int count;
    char *filename;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s etree\n", argv[0]);
        exit(0);
    }
    filename = argv[1];

    /* Create an empty 3d etree with an integer record */
    ep = etree_open(filename, O_RDWR|O_CREAT|O_TRUNC, 1, sizeof(payload_t), 3); 
    if (ep == NULL) {
        fprintf(stderr, "Could not open etree file %s\n", filename);
        exit(1);
    }

    /* Register the schema for the etree to make it portable */
    if (etree_registerschema(ep, "int32_t val; char tag;") != 0) {
        fprintf(stderr, "%s\n", etree_strerror(etree_errno(ep)));
        exit(1);
    }

    /* Initialize the tree with a single root octant */
    /* $begin refineinit */
    root.x = root.y = root.z = 0;
    root.level = ETREE_MAXLEVEL - 2;
    root.type = ETREE_LEAF;
    payload.tag = 'A';
    payload.val = 0;

    if (etree_insert(ep, root, &payload) != 0) {
        fprintf(stderr, "%s", etree_strerror(etree_errno(ep)));
        exit(1);
    }
    /* $end refineinit */

    /* Recursively refine the root octant */
    /* $begin callrefine */
    refine(ep, root);
    count = traverse(ep);
    fprintf(stderr, "The tree has %d octants\n", count);
    /* $end callrefine */

    /* Clean up */
    etree_close(ep);
    exit(0);
}
Пример #3
0
int main(int argc, char **argv)
{
    etree_t *ep;
    etree_addr_t addr, res_addr;
    value_t res_val;
    char buf[ETREE_MAXBUF];

    /* $end query */
    if (argc != 2) {
        fprintf(stderr, "usage: %s etree\n", argv[0]);
        exit(0);
    }
    /* $begin query */
    /* Open the etree for reading */
    ep = etree_open(argv[1], O_RDONLY, 0, sizeof(value_t), 3); 
    if (ep == NULL) {
        fprintf(stderr, "Could not open etree file %s\n", argv[1]);
        exit(1);
    }

    /* Query each octant specified on stdin */
    printf("Input  (x y z t): ");
    addr.level = ETREE_MAXLEVEL;

    while (fgets(buf, ETREE_MAXBUF, stdin)) {
        sscanf(buf, "%u %u %u %u", &addr.x, &addr.y, &addr.z, &addr.t);
	/* $end query */
        /* Ignore comment or blank lines */
        if ((buf[0] == '#') || 
            (buf[0] == '\n') || 
            (buf[0] == '\t')) {
            continue;
        }
	/* $begin query */
        if (etree_search(ep, addr, &res_addr, &res_val) != 0) {
            fprintf(stderr, "%s\n", etree_strerror(etree_errno(ep)));
            printf("Input  (x y z t): ");
	    continue;
        }

	printf("Output (x y z t): %s = %f %f %f\n\n", 
	       etree_straddr(ep, buf, res_addr), res_val.Vx, res_val.Vy,
           res_val.Vz);
	printf("Input  (x y z t): ");
    }

    etree_close(ep);
    exit(0);
}
Пример #4
0
int main( int argc, char** argv )
{
    char*    cvmetree;
    etree_t* cvmEp;
    double east_m, north_m, depth_m;
    cvmpayload_t rawElem;
    int res;

    if (argc != 5) {
	fprintf( stderr, "\nusage: %s cvm_etree_file east_m north_m depth_m\n\n",
		 argv[0] );
	return 1;
    }

    cvmetree = argv[0];
    sscanf( argv[2], "%lf", &east_m  );
    sscanf( argv[3], "%lf", &north_m );
    sscanf( argv[4], "%lf", &depth_m );


    cvmEp = etree_open( cvmetree, O_RDONLY, CVMBUFFERSIZE, 0, 0 );
    if (!cvmEp) {
	perror( "etree_open(...)" );
	fprintf( stderr, "Cannot open CVM material database %s\n", cvmetree );
	return 2;
    }

    res = cvm_query( cvmEp, east_m, north_m, depth_m, &rawElem );

    if (res != 0) {
	fprintf( stderr, "Cannot find the query point\n" );
    } else {
	printf( "\nMaterial property for\n(%f East, %f North, %f Depth)\n",
		east_m, north_m, depth_m );
	printf( "Vp =      %.4f\n", rawElem.Vp );
	printf( "Vs =      %.4f\n", rawElem.Vs );
	printf( "density = %.4f\n", rawElem.rho );
	printf( "\n" );
    }

    etree_close( cvmEp );

    return (res == 0) ? 0 : 3;
}
Пример #5
0
int main(int argc, char **argv)
{
    mesh_t *mesh;
    double double_message[5];
    double x, y, z, factor = 0, vscut = 0;
    double elapsedtime;
#ifndef NO_OUTPUT
    int32_t eindex;
    int32_t remains, batch, idx;
    mrecord_t *partTable;
#endif

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &myID);
    MPI_Comm_size(MPI_COMM_WORLD, &theGroupSize);

    /* Read commandline arguments  */
    if (argc != 5) {
	if (myID == 0) {
	    fprintf(stderr, "usage: qmesh cvmdb physics.in numerical.in ");
	    fprintf(stderr, "meshdb\n");
	    fprintf(stderr,
		    "cvmdb: path to an etree database or a flat file.\n");
	    fprintf(stderr, "physics.in: path to physics.in.\n");
	    fprintf(stderr, "numerical.in: path to numerical.in.\n");
	    fprintf(stderr, "meshetree: path to the output mesh etree.\n");
	    fprintf(stderr, "\n");
	}
	MPI_Finalize();
	return -1;
    }

    /* Change the working directory to $LOCAL */
    /*
    localpath = getenv("LOCAL");
    if (localpath == NULL) {
        fprintf(stderr, "Thread %d: Cannot get $LOCAL value\n", myID);
        MPI_Abort(MPI_COMM_WORLD, ERROR);
        exit(1);
    }

    if (chdir(localpath) != 0) {
        fprintf(stderr, "Thread %d: Cannot chdir to %s\n", myID, localpath);
        MPI_Abort(MPI_COMM_WORLD, ERROR);
        exit(1);
    }
    */

    /* Replicate the material database among the processors */
    /*

    if ((theGroupSize - 1) / PROCPERNODE >= 1) {

        MPI_Comm replica_comm;

        if (myID % PROCPERNODE != 0) {
            MPI_Comm_split(MPI_COMM_WORLD, MPI_UNDEFINED, myID, &replica_comm);

        } else {
            int replica_id;
            off_t filesize, remains, batchsize;
            void *filebuf;
            int fd;

            MPI_Comm_split(MPI_COMM_WORLD, 0, myID, &replica_comm);
            MPI_Comm_rank(replica_comm, &replica_id);

            if (replica_id == 0) {

                struct stat statbuf;


                if (stat(argv[1], &statbuf) != 0) {
                    fprintf(stderr, "Thread 0: Cannot get stat of %s\n",
                            argv[1]);
                    MPI_Abort(MPI_COMM_WORLD, ERROR);
                    exit(1);
                }

                filesize = statbuf.st_size;
            }

            MPI_Bcast(&filesize, sizeof(off_t), MPI_CHAR, 0, replica_comm);

            if ((filebuf = malloc(FILEBUFSIZE)) == NULL) {
                fprintf(stderr, "Thread %d: run out of memory while ", myID);
                fprintf(stderr, "preparing to receive material database\n");
                MPI_Abort(MPI_COMM_WORLD, ERROR);
                exit(1);
            }

	    fd = (replica_id == 0) ?
	    open(argv[1], O_RDONLY) :
                open(argv[1], O_CREAT|O_TRUNC|O_WRONLY, S_IRUSR|S_IWUSR);

            if (fd == -1) {
                fprintf(stderr, "Thread %d: Cannot create replica database\n",
                        myID);
                perror("open");
                MPI_Abort(MPI_COMM_WORLD, ERROR);
                exit(1);
            }

            remains = filesize;
            while (remains > 0) {
                batchsize = (remains > FILEBUFSIZE) ? FILEBUFSIZE : remains;

                if (replica_id == 0) {
                    if (read(fd, filebuf, batchsize) !=  batchsize) {
                        fprintf(stderr, "Thread 0: Cannot read database\n");
                        perror("read");
                        MPI_Abort(MPI_COMM_WORLD, ERROR);
                        exit(1);
                    }
                }

                MPI_Bcast(filebuf, batchsize, MPI_CHAR, 0, replica_comm);

                if (replica_id != 0) {
                    if (write(fd, filebuf, batchsize) != batchsize) {
                        fprintf(stderr, "Thread %d: Cannot write replica ",
                                myID);
                        fprintf(stderr, "database\n");
                        MPI_Abort(MPI_COMM_WORLD, ERROR);
                        exit(1);
                    }
                }

                remains -= batchsize;
		}

            if (close(fd) != 0) {
                fprintf(stderr, "Thread %d: cannot close replica database\n",
                        myID);
                perror("close");
                MPI_Abort(MPI_COMM_WORLD, ERROR);
                exit(1);
            }
	    }

        MPI_Barrier(MPI_COMM_WORLD);

	}

    */



    /* Initialize static global varialbes */
    if (myID == 0) {
	/* Processor 0 reads the parameters */
	if (initparameters(argv[2], argv[3], &x, &y, &z) != 0) {
	    fprintf(stderr, "Thread %d: Cannot init parameters\n", myID);
	    MPI_Abort(MPI_COMM_WORLD, ERROR);
	    exit(1);
	}

	factor = theFactor;
	vscut = theVsCut;
	double_message[0] = x;
	double_message[1] = y;
	double_message[2] = z;
	double_message[3] = factor;
	double_message[4] = vscut;

	/*
          fprintf(stderr, "&double_message[0] = %p\n", &double_message[0]);
          fprintf(stderr, "&double_message[4] = %p\n", &double_message[4]);
	  fprintf(stderr, "Thread 0: %f %f %f %f %f\n", x, y, z, factor, vscut);
        */
    }

    MPI_Bcast(double_message, 5, MPI_DOUBLE, 0, MPI_COMM_WORLD);

    x = double_message[0];
    y = double_message[1];
    z = double_message[2];
    factor = double_message[3];
    vscut  = double_message[4];

    theNorth_m = x;
    theEast_m = y;
    theDepth_m = z;

    /*
      printf("Thread %d: %f %f %f %f %f\n", myID, x, y, z, factor, vscut);
    */

    theFactor = factor;
    theVsCut = vscut;

    MPI_Barrier(MPI_COMM_WORLD);
    elapsedtime = -MPI_Wtime();


    if (myID == 0) {
	fprintf(stdout, "PE = %d, Freq = %.2f\n", theGroupSize, theFreq);
	fprintf(stdout, "-----------------------------------------------\n");
    }


    /*----  Generate and partition an unstructured octree mesh ----*/
    if (myID == 0) {
	fprintf(stdout, "octor_newtree ... ");
    }

    /*
     * RICARDO: Carful with new_octree parameters (cutoff_depth)
     */

    myOctree = octor_newtree(x, y, z, sizeof(edata_t), myID, theGroupSize, MPI_COMM_WORLD, 0);
    if (myOctree == NULL) {
	fprintf(stderr, "Thread %d: fail to create octree\n", myID);
	MPI_Abort(MPI_COMM_WORLD, ERROR);
	exit(1);
    }
    MPI_Barrier(MPI_COMM_WORLD);

    elapsedtime += MPI_Wtime();

    if (myID == 0) {
	fprintf(stdout, "done.... %.2f seconds\n", elapsedtime);
    }

#ifdef USECVMDB
    /* Open my copy of the material database */
    theCVMEp = etree_open(argv[1], O_RDONLY, CVMBUFSIZE, 0, 0);
    if (!theCVMEp) {
	fprintf(stderr, "Thread %d: Cannot open CVM etree database %s\n",
		myID, argv[1]);
	MPI_Abort(MPI_COMM_WORLD, ERROR);
	exit(1);
    }

#else

    /* Use flat data record file and distibute the data in memories */
    elapsedtime = -MPI_Wtime();
    if (myID == 0) {
	fprintf(stdout, "slicing CVM database ...");
    }

    theCVMRecord = sliceCVM(argv[1]);

    MPI_Barrier(MPI_COMM_WORLD);
    elapsedtime += MPI_Wtime();
    if (theCVMRecord == NULL) {
	fprintf(stderr, "Thread %d: Error obtaining the CVM records from %s\n",
		myID, argv[1]);
	MPI_Abort(MPI_COMM_WORLD, ERROR);
	exit(1);
    };
    if (myID == 0) {
	fprintf(stdout, "done.... %.2f seconds\n", elapsedtime);
    }

#endif

    elapsedtime = -MPI_Wtime();
    if (myID == 0) {
	fprintf(stdout, "octor_refinetree ...");
    }
    if (octor_refinetree(myOctree, toexpand, setrec) != 0) {
	fprintf(stderr, "Thread %d: fail to refine octree\n", myID);
	MPI_Abort(MPI_COMM_WORLD, ERROR);
	exit(1);
    }

    MPI_Barrier(MPI_COMM_WORLD);
    elapsedtime += MPI_Wtime();

    if (myID == 0) {
	fprintf(stdout, "done.... %.2f seconds\n", elapsedtime);
    }


    elapsedtime = -MPI_Wtime();
    if (myID == 0) {
	fprintf(stdout, "octor_balancetree ... ");
    }
    if (octor_balancetree(myOctree, setrec, 0) != 0) { /* no progressive meshing (ricardo) */
	fprintf(stderr, "Thread %d: fail to balance octree\n", myID);
	MPI_Abort(MPI_COMM_WORLD, ERROR);
	exit(1);
    }
    MPI_Barrier(MPI_COMM_WORLD);

    elapsedtime += MPI_Wtime();
    if (myID == 0) {
	fprintf(stdout, "done.... %.2f seconds\n", elapsedtime);
    }

#ifdef USECVMDB
    /* Close the material database */
    etree_close(theCVMEp);
#else
    free(theCVMRecord);

#endif /* USECVMDB */

    elapsedtime = -MPI_Wtime();
    if (myID == 0) {
	fprintf(stdout, "octor_partitiontree ...");
    }
    if (octor_partitiontree(myOctree, NULL) != 0) {
	fprintf(stderr, "Thread %d: fail to balance load\n", myID);
	MPI_Abort(MPI_COMM_WORLD, ERROR);
	exit(1);
    }
    MPI_Barrier(MPI_COMM_WORLD);

    elapsedtime +=  MPI_Wtime();
    if (myID == 0) {
	fprintf(stdout, "done.... %.2f seconds\n", elapsedtime);
    }

    elapsedtime = - MPI_Wtime();
    if (myID == 0) {
	fprintf(stdout, "octor_extractmesh ... ");
    }
    mesh = octor_extractmesh(myOctree, NULL);
    if (mesh == NULL) {
	fprintf(stderr, "Thread %d: fail to extract mesh\n", myID);
	MPI_Abort(MPI_COMM_WORLD, ERROR);
	exit(1);
    }
    MPI_Barrier(MPI_COMM_WORLD);

    elapsedtime += MPI_Wtime();
    if (myID == 0) {
	fprintf(stdout, "done.... %.2f seconds\n", elapsedtime);
    }

    /* We can do without the octree now */
    octor_deletetree(myOctree);


    /*---- Obtain and print the statistics of the mesh ----*/
    if (myID == 0) {
	int64_t etotal, ntotal, dntotal;
	int32_t received, procid;
	int32_t *enumTable, *nnumTable, *dnnumTable;
	int32_t rcvtrio[3];

	/* Allocate the arrays to hold the statistics */
	enumTable = (int32_t *)malloc(sizeof(int32_t) * theGroupSize);
	nnumTable = (int32_t *)malloc(sizeof(int32_t) * theGroupSize);
	dnnumTable = (int32_t *)malloc(sizeof(int32_t) * theGroupSize);

	if ((enumTable == NULL) ||
	    (nnumTable == NULL) ||
	    (dnnumTable == NULL)) {
	    fprintf(stderr, "Thread 0: out of memory\n");
	    MPI_Abort(MPI_COMM_WORLD, ERROR);
	    exit(1);
	}

	/* Fill in my counts */
	enumTable[0] = mesh->lenum;
	nnumTable[0] = mesh->lnnum;
	dnnumTable[0] = mesh->ldnnum;

	/* Initialize sums */
	etotal = mesh->lenum;
	ntotal = mesh->lnnum;
	dntotal = mesh->ldnnum;

	/* Fill in the rest of the tables */
	received = 0;
	while (received < theGroupSize - 1) {
	    int32_t fromwhom;
	    MPI_Status status;

	    MPI_Probe(MPI_ANY_SOURCE, STAT_MSG, MPI_COMM_WORLD, &status);

	    fromwhom = status.MPI_SOURCE;

	    MPI_Recv(rcvtrio, 3, MPI_INT, fromwhom, STAT_MSG, MPI_COMM_WORLD,
		     &status);

	    enumTable[fromwhom] = rcvtrio[0];
	    nnumTable[fromwhom] = rcvtrio[1];
	    dnnumTable[fromwhom] = rcvtrio[2];

	    etotal += rcvtrio[0];
	    ntotal += rcvtrio[1];
	    dntotal += rcvtrio[2];

	    received++;
	}

	fprintf(stdout, "Mesh statistics:\n");
	fprintf(stdout, "                 Elements     Nodes    Danglings\n");
#ifdef ALPHA_TRU64UNIX_CC
	fprintf(stdout, "Total     :   %10ld%10ld   %10ld\n\n",
		etotal, ntotal, dntotal);
	for (procid = 0; procid < theGroupSize; procid++) {
	    fprintf(stdout, "Proc %5d:   %10d%10d   %10d\n", procid,
		    enumTable[procid], nnumTable[procid], dnnumTable[procid]);
	}

#else
	fprintf(stdout, "Total      :    %10qd%10qd   %10qd\n\n",
		etotal, ntotal, dntotal);
	for (procid = 0; procid < theGroupSize; procid++) {
	    fprintf(stdout, "Proc %5d:   %10d%10d   %10d\n", procid,
		    enumTable[procid], nnumTable[procid], dnnumTable[procid]);
	}
#endif

	free(enumTable);
	free(nnumTable);
	free(dnnumTable);

    } else {
	int32_t sndtrio[3];

	sndtrio[0] = mesh->lenum;
	sndtrio[1] = mesh->lnnum;
	sndtrio[2] = mesh->ldnnum;

	MPI_Send(sndtrio, 3, MPI_INT, 0, STAT_MSG, MPI_COMM_WORLD);
    }

#ifndef NO_OUTPUT

    /*---- Join elements and nodes, and send to Thread 0 for output */

    /* Allocate a fixed size buffer space to store the join results */
    partTable = (mrecord_t *)calloc(BATCH, sizeof(mrecord_t));
    if (partTable == NULL) {
	fprintf(stderr,	 "Thread %d: out of memory\n", myID);
	MPI_Abort(MPI_COMM_WORLD, ERROR);
	exit(1);
    }

    if (myID == 0) {
	char *mEtree;
	etree_t *mep;
	int32_t procid;

	mEtree = argv[4];
	mep = etree_open(mEtree, O_CREAT|O_RDWR|O_TRUNC, 0, sizeof(mdata_t),3);
	if (mep == NULL) {
	    fprintf(stderr, "Thread 0: cannot create mesh etree\n");
	    MPI_Abort(MPI_COMM_WORLD, ERROR);
	    exit(1);
	}

	/* Begin an appending operation */
	if (etree_beginappend(mep, 1) != 0) {
	    fprintf(stderr, "Thread 0: cannot begin an append operation\n");
	    MPI_Abort(MPI_COMM_WORLD, ERROR);
	    exit(1);
	}

	eindex = 0;
	while (eindex < mesh->lenum) {
	    remains = mesh->lenum - eindex;
	    batch = (remains < BATCH) ? remains : BATCH;

	    for (idx = 0; idx < batch; idx++) {
		mrecord_t *mrecord;
		int32_t whichnode;
		int32_t localnid0;

		mrecord = &partTable[idx];

		/* Fill the address field */
		localnid0 = mesh->elemTable[eindex].lnid[0];

		mrecord->addr.x = mesh->nodeTable[localnid0].x;
		mrecord->addr.y = mesh->nodeTable[localnid0].y;
		mrecord->addr.z = mesh->nodeTable[localnid0].z;
		mrecord->addr.level = mesh->elemTable[eindex].level;
		mrecord->addr.type = ETREE_LEAF;

		/* Find the global node ids for the vertices */
		for (whichnode = 0; whichnode < 8; whichnode++) {
		    int32_t localnid;
		    int64_t globalnid;

		    localnid = mesh->elemTable[eindex].lnid[whichnode];
		    globalnid = mesh->nodeTable[localnid].gnid;

		    mrecord->mdata.nid[whichnode] = globalnid;
		}

		memcpy(&mrecord->mdata.edgesize, mesh->elemTable[eindex].data,
		       sizeof(edata_t));

		eindex++;
	    } /* for a batch */

	    if (bulkload(mep, partTable, batch) != 0) {
		fprintf(stderr, "Thread 0: Error bulk-loading data\n");
		MPI_Abort(MPI_COMM_WORLD, ERROR);
		exit(1);
	    }
	} /* for all the elements Thread 0 has */

	/* Receive data from other processors */
	for (procid = 1; procid < theGroupSize; procid++) {
	    MPI_Status status;
	    int32_t rcvbytecount;

	    /* Signal the next processor to go ahead */
	    MPI_Send(NULL, 0, MPI_CHAR, procid, GOAHEAD_MSG, MPI_COMM_WORLD);

	    while (1) {
		MPI_Probe(procid, MESH_MSG, MPI_COMM_WORLD, &status);
		MPI_Get_count(&status, MPI_CHAR, &rcvbytecount);

		batch = rcvbytecount / sizeof(mrecord_t);
		if (batch == 0) {
		    /* Done */
		    break;
		}

		MPI_Recv(partTable, rcvbytecount, MPI_CHAR, procid,
			 MESH_MSG, MPI_COMM_WORLD, &status);

		if (bulkload(mep, partTable, batch) != 0) {
		    fprintf(stderr, "Thread 0: Cannot bulk-load data from ");
		    fprintf(stderr, "Thread %d\n", procid);
		    MPI_Abort(MPI_COMM_WORLD, ERROR);
		    exit(1);
		}
	    } /* while there is more data to be received from procid */
	} /* for all the processors */

	/* End the appending operation */
	etree_endappend(mep);

	/* Close the mep to ensure the data is on disk */
	if (etree_close(mep) != 0) {
	    fprintf(stderr, "Thread 0: Cannot close the etree database\n");
	    MPI_Abort(MPI_COMM_WORLD, ERROR);
	    exit(1);
	}

    } else {
	/* Processors other than 0 needs to send data to 0 */
	int32_t sndbytecount;
	MPI_Status status;

	/* Wait for my turn */
	MPI_Recv(NULL, 0, MPI_CHAR, 0, GOAHEAD_MSG, MPI_COMM_WORLD, &status);

	eindex = 0;
	while (eindex < mesh->lenum) {
	    remains = mesh->lenum - eindex;
	    batch = (remains < BATCH) ? remains : BATCH;

	    for (idx = 0; idx < batch; idx++) {
		mrecord_t *mrecord;
		int32_t whichnode;
		int32_t localnid0;

		mrecord = &partTable[idx];

		/* Fill the address field */
		localnid0 = mesh->elemTable[eindex].lnid[0];

		mrecord->addr.x = mesh->nodeTable[localnid0].x;
		mrecord->addr.y = mesh->nodeTable[localnid0].y;
		mrecord->addr.z = mesh->nodeTable[localnid0].z;
		mrecord->addr.level = mesh->elemTable[eindex].level;
		mrecord->addr.type = ETREE_LEAF;

		/* Find the global node ids for the vertices */
		for (whichnode = 0; whichnode < 8; whichnode++) {
		    int32_t localnid;
		    int64_t globalnid;

		    localnid = mesh->elemTable[eindex].lnid[whichnode];
		    globalnid = mesh->nodeTable[localnid].gnid;

		    mrecord->mdata.nid[whichnode] = globalnid;
		}

		memcpy(&mrecord->mdata.edgesize, mesh->elemTable[eindex].data,
		       sizeof(edata_t));

		eindex++;
	    } /* for a batch */

	    /* Send data to proc 0 */
	    sndbytecount = batch * sizeof(mrecord_t);
	    MPI_Send(partTable, sndbytecount, MPI_CHAR, 0, MESH_MSG,
		     MPI_COMM_WORLD);
	} /* While there is data left to be sent */

	/* Send an empty message to indicate the end of my transfer */
	MPI_Send(NULL, 0, MPI_CHAR, 0, MESH_MSG, MPI_COMM_WORLD);
    }

    /* Free the memory for the partial join results */
    free(partTable);

#endif

    octor_deletemesh(mesh);

    MPI_Finalize();

    return 0;
}
Пример #6
0
int main(int argc, char **argv)
{
    char    *meshetree, *robIn, *robOut, *cmuOut, *diffile, *diffileA;
    etree_t *meshEp = NULL;
    double   east_m, north_m, depth_m, robVs, robVp, robRho, vsDiff;
    mdata_t  rawElem;
    int      rres=0, mres;//, i=0;

    FILE    *fpRobIn, *fpRobOut, *fpCmuOut, *fpDiff, *fpDiffA;

    double   lon, lat;
    double   domainLengthEta = 600e3;
    double   domainLengthCsi = 300e3;

    double   lonCorners[4] ={-121.0 ,-118.951292, -113.943965, -116.032285};
    double   latCorners[4] ={  34.5 ,  36.621696,   33.122341,   31.082920};

    vector2d_t meshCoords;

    domainLengthEta=600e3;
    domainLengthCsi=300e3;

    /* Capturing input data */

    if (argc != 7) {
        fprintf(stderr, 
            "\nusage: mirrorslice meshetree robfile cmuout robout diffile absfile\n");
        exit(1);
    }

    meshetree = argv[1];
    robIn     = argv[2];
    cmuOut    = argv[3];
    robOut    = argv[4];
    diffile   = argv[5];
    diffileA  = argv[6];

    /* Openning files */

    meshEp = etree_open(meshetree, O_RDONLY, CVMBUFFERSIZE, 0, 0);
    if (!meshEp) {
        fprintf(stderr, "Cannot open mesh etree %s\n", meshetree);
        exit(1);
    }

    fpRobIn = fopen(robIn,"r");
    if ( fpRobIn == NULL ) {
        fprintf(stderr, "Cannot open the Rob input file");
        exit(1);
    }

    fpRobOut = fopen(robOut,"w");
    if ( fpRobOut == NULL ) {
        fprintf(stderr, "Cannot open the Rob output file\n");
        exit(1);
    }

    fpCmuOut = fopen(cmuOut,"w");
    if ( fpCmuOut == NULL ) {
        fprintf(stderr, "Cannot open the CMU output file\n");
        exit(1);
    }

    fpDiff = fopen(diffile,"w");
    if ( fpDiff == NULL ) {
        fprintf(stderr, "Cannot open the Diff output file\n");
        exit(1);
    }
    
    fpDiffA = fopen(diffileA,"w");
    if ( fpDiffA == NULL ) {
        fprintf(stderr, "Cannot open the Diff output file\n");
        exit(1);
    }

    while ( rres != EOF ) {
  //for ( i = 0; i < 10; i++ ) {

        rres = fscanf(fpRobIn,"%lf %lf %lf %lf %lf", 
		      &lon, &lat, &robVp, &robVs, &robRho);

	robVs = robVs * 1000;

	meshCoords = compute_domain_coords_bilin( 
		       lon, lat, 
                       lonCorners, latCorners,
                       domainLengthEta, domainLengthCsi);

	north_m = meshCoords.x[0];
	east_m  = meshCoords.x[1];
	depth_m = 0;

	mres = mesh_query(meshEp, east_m, north_m, depth_m, 
			  NULL, &rawElem.nid[0]);

	if (mres != 0) {
	    fprintf(stderr, "Cannot find the query point\n");
	    exit(1);
	}

	vsDiff = rawElem.Vs - robVs;

	fprintf(fpRobOut, "%12.0f %12.0f %12.4f\n",east_m, north_m, robVs);
	fprintf(fpCmuOut, "%12.0f %12.0f %12.4f\n",east_m, north_m, rawElem.Vs);
	fprintf(fpDiff,   "%12.0f %12.0f %12.4f\n",east_m, north_m, vsDiff);
	fprintf(fpDiffA,  "%12.0f %12.0f %12.4f\n",east_m, north_m, fabs(vsDiff));

    }
    
    /* Closing files */

    fclose(fpRobIn);
    fclose(fpRobOut);
    fclose(fpCmuOut);
    fclose(fpDiff);
    fclose(fpDiffA);
    etree_close(meshEp);

    return 0;
}
Пример #7
0
int main(int argc, char **argv)
{
    char *cvmetree, *outputfile, *outformat;
    FILE *outfp;
    etree_t *cvmEp;
    cvmpayload_t rawElem;
    int64_t totalcount;
    struct timeval starttime, endtime;
    int scantime;
    endian_t myformat, targetformat;
    float outVp, outVs, outrho;
    int outi, outj, outk;

    if (argc != 4) {
        printf("\nusage: dumpcvm cvmetree output format\n");
        printf("cvmetree: pathname to the CVM etree\n");
        printf("output: pathname to the flat output file\n");
        printf("format: little or big\n");
        exit(1);
    }

    cvmetree = argv[1];
    cvmEp = etree_open(cvmetree, O_RDONLY, 0, 0, 0);
    if (!cvmEp) {
        fprintf(stderr, "Cannot open CVM material database %s\n", cvmetree);
        exit(1);
    }


    outputfile = argv[2];
    outfp = fopen(outputfile, "w+");
    if (outfp == NULL) {
        perror("fopen");
        exit(1);
    }
        
    outformat = argv[3];
    if (strcmp(outformat, "little") == 0) {
        targetformat = little;
    } else if (strcmp(outformat, "big") == 0) {
        targetformat = big;
    } else {
        fprintf(stderr, "Unknown target data format\n");
        exit(1);
    }

    myformat = xplatform_testendian();

    /* go through all the records stored in the underlying btree */
    gettimeofday(&starttime, NULL);

    totalcount = 0;
    memset(cvmEp->key, 0, KEYSIZE);

    if (btree_initcursor(cvmEp->bp, cvmEp->key) != 0) {
        fprintf(stderr, "Cannot set cursor in the underlying database\n");
        exit(1);
    }

    do {
        etree_tick_t i, j, k;

        if (btree_getcursor(cvmEp->bp, cvmEp->hitkey, "*", &rawElem) != 0) {
            fprintf(stderr, "Read cursor error\n");
            exit(1);
        } 

        code_morton2coord(ETREE_MAXLEVEL + 1, (char *)cvmEp->hitkey + 1,
                          &i, &j, &k);
                

        /* Write to the output file, do format conversion if necessary */
        if (myformat == targetformat) {
            outi = i; 
            outj = j;
            outk = k;
            outVp = rawElem.Vp;
            outVs = rawElem.Vs;
            outrho = rawElem.rho;
        } else {
            xplatform_swapbytes(&outi, &i, 4);
            xplatform_swapbytes(&outj, &j, 4);
            xplatform_swapbytes(&outk, &k, 4);
            xplatform_swapbytes(&outVp, &rawElem.Vp, 4);
            xplatform_swapbytes(&outVs, &rawElem.Vs, 4);
            xplatform_swapbytes(&outrho, &rawElem.rho, 4);
        }

        if ((fwrite(&outi, 4, 1, outfp) != 1) ||
            (fwrite(&outj, 4, 1, outfp) != 1) ||
            (fwrite(&outk, 4, 1, outfp) != 1) ||
            (fwrite(&outVp, 4, 1, outfp) != 1) ||
            (fwrite(&outVs, 4, 1, outfp) != 1) ||
            (fwrite(&outrho, 4, 1, outfp) != 1)) {
            fprintf(stderr, "Error writing CVM record\n");
            perror("fwrite");
            exit(1);
        }

        
        totalcount++;
    } while (btree_advcursor(cvmEp->bp) == 0);

    if (fclose(outfp) != 0) {
        perror("fclose");
        exit(1);
    }
    etree_close(cvmEp);


    gettimeofday(&endtime, NULL);
    scantime = (endtime.tv_sec - starttime.tv_sec);

    printf("Dump the CVM database in %d seconds\n", scantime);
    printf("Dump %qd octants\n", totalcount);
    printf("Output format is %s-endian", outformat);
    printf("Output file is %s\n", outputfile);
 
    return 0;
}