void dumprsrc(list_t *rl)
{
node_t *rn = rl->next;
while(rn != (node_t*) rl) {
printres((resource_t*)rn->data);
rn = rn->next;
}
}
void test6(){
sqlite3 *db;
int res, i, a, b;
sqlite3_stmt *stmt;
char str[256];
res=sqlite3_open("TEST6", &db); assert(res==0);
// create first table
char *s1 = "CREATE TABLE t1 (a INTEGER PRIMARY KEY, b INT);";
res=sqlite3_prepare(db, s1, -1, &stmt, 0);
if (res){
printf(" Error creating table t1 (table already exists?)\n");
return;
}
res=sqlite3_step(stmt);
if (res != SQLITE_DONE){
printres(res);
return;
}
sqlite3_finalize(stmt);
// insert into first table
for (i=0; i < TEST6_NROWS; ++i){
sprintf(str, "INSERT INTO t1 VALUES (%d,%d);", i, TEST6_NROWS-1-i);
res=sqlite3_prepare(db, str, -1, &stmt, 0); assert(res==0);
do {
res=sqlite3_step(stmt);
} while (res==SQLITE_BUSY);
assert(res==SQLITE_DONE);
sqlite3_finalize(stmt);
}
s1 = "SELECT * FROM t1 ORDER BY b;";
res=sqlite3_prepare(db, s1, -1, &stmt, 0); assert(res==0);
res=sqlite3_step(stmt);
i=0;
do {
if (res==SQLITE_ROW){
res = sqlite3_column_count(stmt);
assert(res==2);
a=sqlite3_column_int(stmt, 0);
b=sqlite3_column_int(stmt, 1);
assert(a==TEST6_NROWS-1-i);
assert(b==i);
}
res=sqlite3_step(stmt);
++i;
} while (res == SQLITE_ROW);
res=sqlite3_finalize(stmt); assert(res==0);
assert(i==TEST6_NROWS);
res=sqlite3_close(db); assert(res==0);
return;
}
// test1: basic test that creates a table, inserts a value, and
// queries for that value repeatedly.
void test1(){
sqlite3 *db;
int res, i;
sqlite3_stmt *stmt;
res=sqlite3_open("TEST1", &db); assert(res==0);
const char *s1 = "CREATE TABLE t1 (a INTEGER PRIMARY KEY, b INT);";
res=sqlite3_prepare(db, s1, -1, &stmt, 0);
if (res){
printf(" Error creating table (table already exists?)\n");
return;
}
res=sqlite3_step(stmt);
if (res != SQLITE_DONE){
printres(res);
return;
}
sqlite3_finalize(stmt);
s1 = "INSERT INTO t1 VALUES (1,2);";
res=sqlite3_prepare(db, s1, -1, &stmt, 0); assert(res==0);
res=sqlite3_step(stmt);
if (res != SQLITE_DONE){
printres(res);
return;
}
sqlite3_finalize(stmt);
s1 = "SELECT * FROM t1 WHERE a=1;";
for (i=0; i < TEST1_REPS; ++i){
res=sqlite3_prepare(db, s1, -1, &stmt, 0); assert(res==0);
res=sqlite3_step(stmt);
res=sqlite3_finalize(stmt); assert(res==0);
}
res=sqlite3_close(db); assert(res==0);
return;
}
void nqueens(vector<int> A, int cur, int n)
{
if (cur == n)
printres(A, n);
else
{
for (int i = 0; i < n; i++)
{
A[cur] = i;
if (isValid(A, cur))
nqueens(A, cur + 1, n);
}
}
}
void dumponersrc(const char *num)
{
int n;
node_t *rn;
n = readnum (num);
rn = resource_list.next;
while(rn != (node_t*) &resource_list) {
if (((resource_t*)rn->data)->id == n) {
printres((resource_t*) rn->data);
break;
} else {
rn = rn->next;
}
}
}
void dumpteam(int id)
{
node_t *rn;
team_t *team = rsrc_find_team(id);
if(team){
kprintf("team %d (%s)...",team->rsrc.id,team->rsrc.name);
rn = team->resources.next;
while(rn != (node_t*) &team->resources) {
printres((resource_t*) rn->data);
rn = rn->next;
}
} else {
kprintf("no such team %d",id);
}
}
void
telnet_readcb(struct bufferevent *bev, void *parameter)
{
struct argument *arg = parameter;
struct evbuffer *input = EVBUFFER_INPUT(bev);
struct telnet_state *state = arg->a_state;
DFPRINTF((stderr, "%s: called\n", __func__));
if (arg->a_flags == 0) {
int res = telnet_makeconnect(bev, arg);
if (res == -1) {
evbuffer_add(input, "", 1);
printres(arg, arg->a_ports[0].port,
EVBUFFER_DATA(input));
scanhost_return(bev, arg, 0);
return;
} else if (res == 1) {
arg->a_flags = TELNET_WAITING_CONNECT;
bufferevent_disable(bev, EV_READ);
}
} else if (arg->a_flags & TELNET_READING_CONNECT) {
if (evbuffer_find(input, state->connect_wait,
strlen(state->connect_wait)) == NULL)
return;
evbuffer_drain(input, EVBUFFER_LENGTH(input));
arg->a_flags = TELNET_WRITING_COMMAND;
bufferevent_disable(bev, EV_READ);
http_makerequest(bev, arg, socks_getword(), 0);
} else if (arg->a_flags & TELNET_WAITING_RESPONSE) {
int res = http_bufferanalyse(bev, arg);
if (res == -1)
return;
if (res == 1) {
postres(arg, state->response);
scanhost_return(bev, arg, 1);
}
}
return;
}
// routine running RND
void rundev(librandom::RandomDev *rnd, const unsigned long N)
{
double sum = 0;
double sum2= 0;
double x;
std::clock_t t1, t2;
t1 = std::clock();
for (unsigned long k = 0 ; k < N ; k++ ) {
x = (*rnd)();
// std::cout << x << std::endl;
sum += x;
sum2 += std::pow(x, 2);
}
t2 = std::clock();
double dt = double(t2-t1) / CLOCKS_PER_SEC * 1000; // ms
double mean = sum / N;
double sdev = std::sqrt(sum2/N - std::pow(mean,2));
printres(mean, sdev, dt);
}
int main(void)
{
// create random number generator type dictionary
Dictionary rngdict;
DictionaryDatum rngdictd(rngdict);
// add non-GSL rngs
register_rng<librandom::KnuthLFG>("KnuthLFG", rngdictd);
register_rng<librandom::MT19937>("MT19937", rngdictd);
// let GslRandomGen add all of the GSL rngs
librandom::GslRandomGen::add_gsl_rngs(rngdictd);
// run all available RNG
std::cout << std::endl
<< "==========================================================="
<< std::endl << std::endl;
std::cout << "Available random generators---Generating "
<< Ngen << " numbers" << std::endl;
std::cout << "-----------------------------------------------------------"
<< std::endl;
// check all implementations
for ( Dictionary::const_iterator it = rngdict.begin() ;
it != rngdict.end() ; ++it )
{
std::cout << std::left << std::setw(25) << it->first << ": ";
librandom::RngFactoryDatum fd = getValue<librandom::RngFactoryDatum>(it->second);
librandom::RngPtr rp = fd->create(librandom::RandomGen::DefaultSeed);
rungen(rp, Ngen);
}
std::cout << std::left << std::setw(25) << "Expected" << ": ";
printres(0.5, 1.0/std::sqrt(12.0), -1);
std::cout << std::endl
<< "==========================================================="
<< std::endl;
// random deviates
std::cout << std::endl
<< "Available random deviates---Generating "
<< Ndev << " numbers" << std::endl
<< "-----------------------------------------------------------"
<< std::endl << std::endl;
// create default generator for deviate generation
librandom::RngFactoryDatum rngfact
= getValue<librandom::RngFactoryDatum>(rngdict.begin()->second);
librandom::RngPtr lockrng = rngfact->create(librandom::RandomGen::DefaultSeed);
librandom::RandomDev* rnd;
// Poisson
{
std::cout << std::left << std::setw(25) << "Poisson (lam=1)" << " : ";
lockrng->seed(seed);
rnd = new librandom::PoissonRandomDev(lockrng,1);
rundev(rnd, Ndev);
std::cout << std::left << std::setw(25) << "Expected" << " : ";
printres(1.0, 1.0, -1);
std::cout << std::endl;
}
// Normal
{
std::cout << std::left << std::setw(25) << "Normal" << " : ";
lockrng->seed(seed);
rnd = new librandom::NormalRandomDev(lockrng);
rundev(rnd, Ndev);
std::cout << std::left << std::setw(25) << "Expected" << " : ";
printres(0.0, 1.0, -1);
std::cout << std::endl;
}
// Exponential
{
std::cout << std::left << std::setw(25) << "Exponential" << " : ";
lockrng->seed(seed);
rnd = new librandom::ExpRandomDev(lockrng);
rundev(rnd, Ndev);
std::cout << std::left << std::setw(25) << "Expected" << " : ";
printres(1.0, 1.0, -1);
std::cout << std::endl;
}
// Gamma
{
std::cout << std::left << std::setw(25) << "Gamma (Order 4)" << " : ";
lockrng->seed(seed);
rnd = new librandom::GammaRandomDev(lockrng, 4);
rundev(rnd, Ndev);
std::cout << std::left << std::setw(25) << "Expected" << " : ";
printres(4.0, 2.0, -1);
std::cout << std::endl;
}
// Binomial
{
std::cout << std::left << std::setw(25) << "Binom (0.25, 8)" << " : ";
lockrng->seed(seed);
rnd = new librandom::BinomialRandomDev(lockrng, 0.25, 8);
rundev(rnd, Ndev);
std::cout << std::left << std::setw(25) << "Expected" << " : ";
printres(2.0, 1.2247, -1);
std::cout << std::endl;
}
std::cout << std::endl
<< "==========================================================="
<< std::endl;
return 0;
}
// common function for test7 and test5
void test7(){
sqlite3 *db;
int res, i, j, a, b;
sqlite3_stmt *stmt;
char str[256];
res=sqlite3_open("TEST7", &db); assert(res==0);
// create table
char *s1 = "CREATE TABLE t1 (a INTEGER PRIMARY KEY, b INT);";
res=sqlite3_prepare(db, s1, -1, &stmt, 0);
if (res){
printf(" Error creating table t1 (table already exists?)\n");
return;
}
res=sqlite3_step(stmt);
if (res != SQLITE_DONE){
printres(res);
return;
}
sqlite3_finalize(stmt);
// run transactions
for (i=0; i < TEST7_TXS; ++i){
do {
s1 = "BEGIN TRANSACTION;";
res=sqlite3_prepare(db, s1, -1, &stmt, 0); assert(!res);
res=sqlite3_step(stmt); assert(res==SQLITE_DONE);
sqlite3_finalize(stmt);
for (j=0; j < TEST7_OPS; ++j){
sprintf(str, "INSERT INTO t1 VALUES (%d,%d);", i*TEST7_OPS+j,
i*TEST7_OPS+j);
res=sqlite3_prepare(db, str, -1, &stmt, 0); assert(res==0);
do {
res=sqlite3_step(stmt);
if (res==SQLITE_BUSY) putchar('B');
} while (res==SQLITE_BUSY);
assert(res==SQLITE_DONE);
sqlite3_finalize(stmt);
}
s1 = "COMMIT TRANSACTION;";
res=sqlite3_prepare(db, s1, -1, &stmt, 0);
if (res == SQLITE_BUSY){
putchar('C');
goto test7_busy;
}
assert(!res);
res=sqlite3_step(stmt);
if (res == SQLITE_BUSY){
putchar('D');
goto test7_busy;
}
assert(res==SQLITE_DONE);
test7_busy:
sqlite3_finalize(stmt);
} while (res == SQLITE_BUSY);
}
s1 = "SELECT * FROM t1 ORDER BY a;";
res=sqlite3_prepare(db, s1, -1, &stmt, 0); assert(res==0);
res=sqlite3_step(stmt);
i=0;
do {
if (res==SQLITE_ROW){
res = sqlite3_column_count(stmt);
assert(res==2);
a=sqlite3_column_int(stmt, 0);
b=sqlite3_column_int(stmt, 1);
assert(a==i);
assert(b==i);
}
res=sqlite3_step(stmt);
++i;
} while (res == SQLITE_ROW);
res=sqlite3_finalize(stmt); assert(res==0);
assert(i==TEST7_TXS * TEST7_OPS);
res=sqlite3_close(db); assert(res==0);
return;
}
// common function for test4 and test5
void test4and5_common(char *dbname, bool indexfirst){
sqlite3 *db;
int res, i, j, a, b, c;
sqlite3_stmt *stmt;
char str[256];
res=sqlite3_open(dbname, &db); assert(res==0);
// create first table
char *s1 = "CREATE TABLE t1 (a INTEGER PRIMARY KEY, b INT);";
res=sqlite3_prepare(db, s1, -1, &stmt, 0);
if (res){
printf(" Error creating table t1 (table already exists?)\n");
return;
}
res=sqlite3_step(stmt);
if (res != SQLITE_DONE){
printres(res);
return;
}
sqlite3_finalize(stmt);
// create second table
s1 = "CREATE TABLE t2 (c INT, d INT);";
res=sqlite3_prepare(db, s1, -1, &stmt, 0);
if (res){
printf(" Error creating table t2 (table already exists?)\n");
return;
}
res=sqlite3_step(stmt);
if (res != SQLITE_DONE){
printres(res);
return;
}
sqlite3_finalize(stmt);
if (indexfirst){
// create index
s1 = "CREATE INDEX i1 ON t2(c);";
res=sqlite3_prepare(db, s1, -1, &stmt, 0);
if (res){
printf(" Error creating table t2 (table already exists?)\n");
return;
}
res=sqlite3_step(stmt);
if (res != SQLITE_DONE){
printres(res);
return;
}
sqlite3_finalize(stmt);
}
// insert into first table
for (i=0; i < TEST4_NROWS; ++i){
sprintf(str, "INSERT INTO t1 VALUES (%d,%d);", i, i);
res=sqlite3_prepare(db, str, -1, &stmt, 0); assert(res==0);
do {
res=sqlite3_step(stmt);
} while (res==SQLITE_BUSY);
assert(res==SQLITE_DONE);
sqlite3_finalize(stmt);
}
// insert into second table
for (i=0; i < TEST4_NROWS; ++i){
for (j=0; j < TEST4_NJOINS; ++j){
sprintf(str, "INSERT INTO t2 VALUES (%d,%d);", i, j);
res=sqlite3_prepare(db, str, -1, &stmt, 0); assert(res==0);
do {
res=sqlite3_step(stmt);
} while (res==SQLITE_BUSY);
assert(res==SQLITE_DONE);
sqlite3_finalize(stmt);
}
}
if (!indexfirst){
// create index
s1 = "CREATE INDEX i1 ON t2(c);";
res=sqlite3_prepare(db, s1, -1, &stmt, 0);
if (res){
printf(" Error creating table t2 (table already exists?)\n");
return;
}
res=sqlite3_step(stmt);
if (res != SQLITE_DONE){
printres(res);
return;
}
sqlite3_finalize(stmt);
}
s1 = "SELECT * FROM t1 JOIN t2 on t1.b=t2.c;";
res=sqlite3_prepare(db, s1, -1, &stmt, 0); assert(res==0);
res=sqlite3_step(stmt);
i=0;
do {
if (res==SQLITE_ROW){
res = sqlite3_column_count(stmt);
assert(res==4);
a=sqlite3_column_int(stmt, 0);
b=sqlite3_column_int(stmt, 1);
c=sqlite3_column_int(stmt, 2);
// d=sqlite3_column_int(stmt, 3);
assert(a==b);
assert(b==c);
}
res=sqlite3_step(stmt);
++i;
} while (res == SQLITE_ROW);
res=sqlite3_finalize(stmt); assert(res==0);
assert(i==TEST4_NROWS * TEST4_NJOINS);
res=sqlite3_close(db); assert(res==0);
return;
}
/*--------------------------------------------------------------*/
int main (int argc, char *argv[])
{
static int n, npoints, nfin, nfout1, nfout2, ierr, nprpv;
static double t0, dt, delta, vmin, vmax, tmin, tmax;
static double snr, tresh, ffact, perc, taperl,fmatch,piover4;
static float sei[16384], sei_p[32768], sei_n[16384];
static double arr1[100][8],arr2[100][7];
static double c_per[100],g_vel[100],amp_p[100],amp_n[100];
static double tamp, ampo[32][32768], pred[2][300];
static int nrow, ncol, npred;
static double prpvper[300],prpvvel[300]; // phase vel prediction files
double snr_p[64], snr_n[64];
double f1,f2,f3,f4,dom_am;
char *p,name[160],name1[160],buf[200],str[160],phvelname[160],root[160];
char amp_name[100];
FILE *in, *fd, *inv, *fas;
int i, j, flag, k, len, n_am, i_am;
int nn,sac = 1; // =1 - SAC, =0 - ftat files
// input command line arguments treatment
if(argc != 2) {
printf("Usage: aftan_amp [parameter file]\n");
exit(-1);
}
// open and read contents of parameter file
if((in = fopen(argv[1],"r")) == NULL) {
printf("Can not find file %s.\n",argv[1]);
exit(1);
}
while((n = fscanf(in,"%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %s %d",
&piover4,&vmin,&vmax,&tmin,&tmax,&tresh,&ffact,&taperl,&snr,&fmatch,
name,&flag)) != EOF) { // start main loop
strcpy(root,name);
p = strrchr(root,'.');
*(p+1) = '\0';
//strcpy(phvelname,root);
//strcat(phvelname,"SAC_PHP");
if(n == 0 || n != 12) break;
printf("vmin= %lf, vmax= %lf, tmin= %lf, tmax= %lf\n",
vmin,vmax,tmin,tmax);
// remove quotes from file names
j = 0;
for(i = 0; i < strlen(name); i++) {
if(name[i] == '\'' || name[i] == '\"') continue;
name[j] = name[i]; j++;
}
name[j] = '\0';
printf("Tresh= %lf, Filter factor= %lf, SNR= %lf, Match = %lf\nData file name=%s\n",
tresh,ffact,snr,fmatch,name);
// if presents, read phase velocity prediction file
// ---
nprpv = -1;
/*
* read phase velocity information
*/
// strtok(root,"_");
// strcpy(sta1,strtok(NULL,"_"));
// strcpy(sta2,strtok(NULL,"."));
// sscanf(root, "%[A-Z,a-z,0-9]_%[A-Z,a-z,0-9].", sta1, sta2);
sprintf(phvelname, "/home/tianye/code/Programs/head/scalifornia_avg_phvel.dat");
// sprintf(phvelname, "%s/%s/%s_%s.dat",argv[2],sta1,sta1,sta2);
// fprintf(stderr, "predicted phase velocity %s \n",phvelname);
// if((inv = fopen(phvelname,"r")) == NULL) {
// printf("Can not find file %s. Use the inversed path instead\n",phvelname);
// sprintf(phvelname, "%s/%s/%s_%s.dat",argv[2],sta2,sta2,sta1);
if((inv = fopen(phvelname,"r")) == NULL) {
printf("Can not find file %s.\n",phvelname);
nprpv = 0;
//goto next;
continue;
}
// }
fgets(buf,200,inv);
while(fgets(buf,200,inv) != NULL) {
if(nprpv == -1) { nprpv++; continue; }
if((n = sscanf(buf,"%lf %lf",&prpvper[nprpv],&prpvvel[nprpv])) < 2) break;
nprpv++;
}
fclose(inv);
printf("Phase velocity prediction file name= %s\n",phvelname);
// next:
/*
* read SAC or ascii data
*/
readdata(sac,name,&n,&dt,&delta,&t0,sei_p);
if(flag==1) {
len=(n-1)/2;
for(k=0;k<=len;k++) sei_n[k]=sei_p[len-k];
for(k=0;k<=len;k++) sei_p[k]=sei_p[len+k];
for(k=0;k<=len;k++) sei[k]=(sei_p[k]+sei_n[k])/2.;
n=len+1;
t0 += len*dt;
}
else
for(k=0;k<n;k++) sei[k]=sei_p[k];
/*
* Read group velocity prediction file
*/
// strcpy(name1,root);
// strcat(name1,"SAC_GRP");
// sscanf(root, "%[A-Z,a-z,0-9]_%[A-Z,a-z,0-9].", sta1, sta2);
//sprintf(name1, "/home/linf/California/PRED_DISP/COR_%s_%s.SAC_PRED", sta1, sta2);
//printf("Group velocity prediction curve: %s\n",name1);
//if((fd = fopen(name1,"r")) == NULL) {
// printf("Can not find file %s.\n",name1);
// exit(1);
//}
//i = 0;
//fgets(str,100,fd);
//while((nn = fscanf(fd,"%lf %lf",&pred[0][i],&pred[1][i])) == 2) i++;
//npred = i;
//fclose(fd);
/* ====================================================================
* Parameters for aftanipg function:
* Input parameters:
* piover4 - phase shift = pi/4*piover4, for cross-correlation
* piover4 should be -1.0 !!!! (double)
* n - number of input samples, (int)
* sei - input array length of n, (float)
* t0 - time shift of SAC file in seconds, (double)
* dt - sampling rate in seconds, (double)
* delta - distance, km (double)
* vmin - minimal group velocity, km/s (double)
* vmax - maximal value of the group velocity, km/s (double)
* tmin - minimal period, s (double)
* tmax - maximal period, s (double)
* tresh - treshold, usually = 10, (double)
* ffact - factor to automatic filter parameter, (double)
* perc - minimal length of of output segment vs freq. range, % (double)
* npoints - max number points in jump, (int)
* taperl - factor for the left end seismogram tapering,
* taper = taperl*tmax, (double)
* nfin - starting number of frequencies, nfin <= 32, (int)
* snr - phase match filter parameter, spectra ratio to
* determine cutting point (double)
* fmatch - factor to length of phase matching window
* npred - length of prediction table
* pred - prediction table: pred[0][] - periods in sec,
* pred[1][] - pedicted velocity, km/s
* flag - Input file type: 0 for single-sided, 1 for double-sided
* ==========================================================
* Output parameters are placed in 2-D arrays arr1 and arr2,
* arr1 contains preliminary results and arr2 - final.
* ==========================================================
* nfout1 - output number of frequencies for arr1, (int)
* arr1 - the first nfout1 raws contain preliminary data,
* (double arr1[n][5], n >= nfout1)
* arr1[:,0] - central periods, s (double)
* arr1[:,1] - apparent periods, s (double)
* arr1[:,2] - group velocities, km/s (double)
* arr1[:,3] - phase velocities, km/s (double)
* arr1[:,4] - amplitudes, Db (double)
* arr1[:,5] - discrimination function, (double)
* arr1[:,6] - signal/noise ratio, Db (double)
* arr1[:,7] - maximum half width, s (double)
* nfout2 - output number of frequencies for arr2, (int)
* If nfout2 == 0, no final result.
* arr2 - the first nfout2 raws contains final data,
* (double arr2[n][5], n >= nfout2)
* arr2[:,0] - central periods, s (double)
* arr2[:,1] - apparent periods, s (double)
* arr2[:,2] - group velocities, km/s (double)
* arr2[:,3] - amplitudes, Db (double)
* arr2[:,4] - signal/noise ratio, Db (double)
* arr2[:,5] - maximum half width, s (double)
* tamp - time to the beginning of ampo table, s (double)
* nrow - number of rows in array ampo, (int)
* ncol - number of columns in array ampo, (int)
* ampo - Ftan amplitude array, Db, (double [32][32768])
* ierr - completion status, =0 - O.K., (int)
* =1 - some problems occures
* =2 - no final results
*/
// t0 = 0.0;
nfin = 32;
npoints = 10; // only 3 points in jump
perc = 50.0; // 50 % for output segment
// taperl = 2.0; // factor to the left end tapering
printf("pi/4 = %5.1lf, t0 = %9.3lf\n",piover4,t0);
printf("#filters= %d, Perc= %6.2f %s, npoints= %d, Taper factor= %6.2f\n",
nfin,perc,"%",npoints,taperl);
/* Call aftanipg function, FTAN + prediction */
// printf("FTAN + prediction curve\n");
//ffact =2.0;
//aftanipg_(&piover4,&n,sei,&t0,&dt,&delta,&vmin,&vmax,&tmin,&tmax,&tresh,
// &ffact,&perc,&npoints,&taperl,&nfin,&snr,&fmatch,&npred,pred,
// &nprpv,prpvper,prpvvel,
// &nfout1,arr1,&nfout2,arr2,&tamp,&nrow,&ncol,ampo,&ierr);
//printres(dt,nfout1,arr1,nfout2,arr2,tamp,nrow,ncol,ampo,ierr,name,"_P");
//if(nfout2 == 0) continue; // break aftan sequence
//printf("Tamp = %9.3lf, nrow = %d, ncol = %d\n",tamp,nrow,ncol);
/* Pre-whiten and record the amp factor */
f1=1./tmax/1.25;
f2=1./tmax;
f3=1./tmin;
f4=1./tmin/1.25;
filter4_(&f1,&f2,&f3,&f4,&dt,&n,sei,&n_am,&dom_am);
// printf("%lf %lf %lf\n",amp_rec[180],amp_rec[1000],amp_rec[1600]);
// printf("%d %lf\n",n_am/2+1,dom_am);
/* FTAN with phase match filter. First Iteration. */
printf("FTAN - the first iteration\n");
ffact =1.0;
aftanpg_(&piover4,&n,sei,&t0,&dt,&delta,&vmin,&vmax,&tmin,&tmax,&tresh,
&ffact,&perc,&npoints,&taperl,&nfin,&snr,&nprpv,prpvper,prpvvel,
&nfout1,arr1,&nfout2,arr2,&tamp,&nrow,&ncol,ampo,&ierr);
// printres(dt,nfout1,arr1,nfout2,arr2,tamp,nrow,ncol,ampo,ierr,name,"_1");
if(nfout2 == 0) continue; // break aftan sequence
printf("Tamp = %9.3lf, nrow = %d, ncol = %d\n",tamp,nrow,ncol);
/* Make prediction based on the first iteration */
npred = nfout2;
tmin = arr2[0][1];
tmax = arr2[nfout2-1][1];
for(i = 0; i < nfout2; i++) {
pred[0][i] = arr2[i][1]; // apparent period // central periods
pred[1][i] = arr2[i][2]; // group velocities
}
/* FTAN with phase with phase match filter. Second Iteration. */
printf("FTAN - the second iteration (phase match filter)\n");
ffact = 2.0;
aftanipg_(&piover4,&n,sei,&t0,&dt,&delta,&vmin,&vmax,&tmin,&tmax,&tresh,
&ffact,&perc,&npoints,&taperl,&nfin,&snr,&fmatch,&npred,pred,
&nprpv,prpvper,prpvvel,
&nfout1,arr1,&nfout2,arr2,&tamp,&nrow,&ncol,ampo,&ierr);
printf("Tamp = %9.3lf, nrow = %d, ncol = %d\n",tamp,nrow,ncol);
printres(dt,nfout1,arr1,nfout2,arr2,tamp,nrow,ncol,ampo,ierr,name,"_2");
for(i = 0; i < nfout2; i++) {
c_per[i]=arr2[i][0];
g_vel[i]=arr2[i][2];
}
get_snr(sei_p,n,dt,delta,t0,c_per,g_vel,nfout2,amp_p,snr_p);
if(flag==1) get_snr(sei_n,n,dt,delta,t0,c_per,g_vel,nfout2,amp_n,snr_n);
sprintf(amp_name,"%s_amp_snr",name);
if((fas=fopen(amp_name,"w"))==NULL) {
printf("Cannot open file %s to write!\n");
exit (1);
}
if(flag==1) for(i = 0; i < nfout2; i++)
fprintf(fas,"%8.4f %.5g %8.4f %.5g %8.4f\n",arr2[i][1],amp_p[i],snr_p[i],amp_n[i],snr_n[i]);
else for(i = 0; i < nfout2; i++)
fprintf(fas,"%8.4f %.5g %8.4f\n",arr2[i][1],amp_p[i],snr_p[i]);
fclose(fas);
}
fclose(in);
return 0;
}
int main(int argc,char * argv[])
{
int rank,size,i;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&rank);
MPI_Comm_size(MPI_COMM_WORLD,&size);
if(rank==0)
{
if(!readFromFile())
exit(-1);
if(size>2*variableNum)
{
printf("Too many Processors,reduce your -np value \n");
MPI_Abort(MPI_COMM_WORLD,1);
}
beginTime=MPI_Wtime();
for(int i=1;i<size;i++)
{
MPI_Send(&variableNum,1,MPI_INT,i,V_TAG,MPI_COMM_WORLD);
MPI_Send(p,variableNum*2,MPI_DOUBLE,i,P_TAG,MPI_COMM_WORLD);
}
addTransTime(MPI_Wtime()-beginTime);
}
else
{
MPI_Recv(&variableNum,1,MPI_INT,0,V_TAG,MPI_COMM_WORLD,&status);
MPI_Recv(p,variableNum*2,MPI_DOUBLE,0,P_TAG,MPI_COMM_WORLD,&status);
}
int wLength=2*variableNum;
for(i=0;i<wLength;i++)
{
w[i].real=cos(i*2*PI/wLength);
w[i].imag=sin(i*2*PI/wLength);
}
int everageLength=wLength/size;
int moreLength=wLength%size;
int startPos=moreLength+rank*everageLength;
int stopPos=startPos+everageLength-1;
if(rank==0)
{
startPos=0;
stopPos=moreLength+everageLength-1;
}
evaluate(p,0,variableNum-1,w,s,startPos,stopPos,wLength);
if(rank>0)
{
MPI_Send(s+startPos,everageLength*2,MPI_DOUBLE,0,S_TAG,MPI_COMM_WORLD);
MPI_Recv(s,wLength*2,MPI_DOUBLE,0,S_TAG2,MPI_COMM_WORLD,&status);
}
else
{
double tempTime=MPI_Wtime();
for(i=1;i<size;i++)
{
MPI_Recv(s+moreLength+i*everageLength,everageLength*2,MPI_DOUBLE,i,S_TAG,MPI_COMM_WORLD,&status);
}
for(i=1;i<size;i++)
{
MPI_Send(s,wLength*2,MPI_DOUBLE,i,S_TAG2,MPI_COMM_WORLD);
}
printf("The final results :\n");
printres(s,wLength);
addTransTime(MPI_Wtime()-tempTime);
}
if(rank==0)
{
totalTime=MPI_Wtime();
totalTime-=beginTime;
printf("\nUse prossor size=%d\n",size);
printf("Total running time=%f(s)\n",totalTime);
printf("Distribute data time = %f(s)\n",transTime);
printf("Parallel compute time = %f(s)\n ",totalTime-transTime);
}
MPI_Finalize();
return 0;
}
int main(int argc,char * argv[])
{
int rank,size,i;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&rank);
MPI_Comm_size(MPI_COMM_WORLD,&size);
// 分发数据
if(rank==0)
{
// 0# 进程从文件读入多项式p的阶数和系数序列
if(!readFromFile())
exit(-1);
// 进程数目太多，造成每个进程平均分配不到一个元素，异常退出
if(size>2*variableNum)
{
printf("Too many Processors,reduce your -np value \n");
MPI_Abort(MPI_COMM_WORLD,1);
}
beginTime=MPI_Wtime();
// 0#进程把多项式的阶数,p发送给其它进程
sendOrigData(size);
// 累计传输时间
addTransTime(MPI_Wtime()-beginTime);
}
else // 其它进程接收进程0发送来的数据，包括variableNum、数组p
{
recvOrigData();
}
// 初始化数组w，用于进行傅立叶变换
int wLength=2*variableNum;
for(i=0;i<wLength;i++)
{
w[i].r=cos(i*2*PI/wLength);
w[i].i=sin(i*2*PI/wLength);
}
// 划分各个进程的工作范围 startPos ~ stopPos
int everageLength=wLength/size; // 8/2=4 (假设有两个进程)
int moreLength=wLength%size; // 8%2=0
int startPos=moreLength+rank*everageLength; // 0+0*4=0; 0+1*4=4;
int stopPos=startPos+everageLength-1; // 0+4-1=3; 4+4-1=7;
//[0,1,2,3,4,5,6,7], 片段: [0,3], [4,7]
if(rank==0)
{
startPos=0; // 0
stopPos=moreLength+everageLength-1; // 0+4-1=3
}
// 对p作FFT，输出序列为s，每个进程仅负责计算出序列中位置为 startPos 到 stopPos 的元素
evaluate(p,0,variableNum-1,w,s,startPos,stopPos,wLength);
// p 原始序列
// 0 原始序列在数组f中的第一个下标
// variableNum-1 原始序列在数组f中的最后一个下标
// w 存放单位根的数组，其元素为w,w^2,w^3...
// s 输出序列
// startPos 所负责计算输出的y的片断的起始下标
// stopPos 所负责计算输出的y的片断的终止下标
// wLength s的长度
printf("partial results, process %d.\n",rank);
myprint(s,wLength); // 输出每个进程的结果(部分结果)
// 各个进程都把s中自己负责计算出来的部分发送给进程0，并从进程0接收汇总的s
if(rank>0)
{
MPI_Send(s+startPos,everageLength*2,MPI_DOUBLE,0,S_TAG,MPI_COMM_WORLD);
MPI_Recv(s,wLength*2,MPI_DOUBLE,0,S_TAG2,MPI_COMM_WORLD,&status);
}
else // 进程0接收s片段，向其余进程发送完整的s
{
double tempTime=MPI_Wtime();
// 进程0接收s片段
for(i=1;i<size;i++)
{
MPI_Recv(s+moreLength+i*everageLength,everageLength*2,MPI_DOUBLE,i,S_TAG,MPI_COMM_WORLD,&status);
}
//进程0向其余进程发送完整的结果s
for(i=1;i<size;i++)
{
MPI_Send(s,wLength*2,MPI_DOUBLE,i,S_TAG2,MPI_COMM_WORLD);
}
printf("The final results :\n");
printres(s,wLength); //结果占s一半空间
addTransTime(MPI_Wtime()-tempTime);
}
if(rank==0)
{
totalTime=MPI_Wtime();
totalTime-=beginTime;
printf("\nUse prossor size=%d\n",size);
printf("Total running time=%f(s)\n",totalTime);
printf("Distribute data time = %f(s)\n",transTime);
printf("Parallel compute time = %f(s)\n ",totalTime-transTime);
}
MPI_Finalize();
}
