double EncoderLearnerTagger::gradient(double *expected) {
viterbi();
for (int pos = 0; pos <= static_cast<long>(len_); ++pos) {
for (LearnerNode *node = begin_node_list_[pos]; node; node = node->bnext) {
calc_alpha(node);
}
}
for (int pos = static_cast<long>(len_); pos >=0; --pos) {
for (LearnerNode *node = end_node_list_[pos]; node; node = node->enext) {
calc_beta(node);
}
}
double Z = begin_node_list_[len_]->alpha; // alpha of EOS
for (int pos = 0; pos <= static_cast<long>(len_); ++pos) {
for (LearnerNode *node = begin_node_list_[pos]; node; node = node->bnext) {
for (LearnerPath *path = node->lpath; path; path = path->lnext) {
calc_expectation(path, expected, Z);
}
}
}
for (size_t i = 0; i < ans_path_list_.size(); ++i) {
Z -= ans_path_list_[i]->cost;
}
return Z;
}
// static
bool Viterbi::forwardbackward(Lattice *lattice) {
if (!lattice->has_request_type(MECAB_MARGINAL_PROB)) {
return true;
}
Node **end_node_list = lattice->end_nodes();
Node **begin_node_list = lattice->begin_nodes();
const size_t len = lattice->size();
const double theta = lattice->theta();
end_node_list[0]->alpha = 0.0;
for (int pos = 0; pos <= static_cast<long>(len); ++pos) {
for (Node *node = begin_node_list[pos]; node; node = node->bnext) {
calc_alpha(node, theta);
}
}
begin_node_list[len]->beta = 0.0;
for (int pos = static_cast<long>(len); pos >= 0; --pos) {
for (Node *node = end_node_list[pos]; node; node = node->enext) {
calc_beta(node, theta);
}
}
const double Z = begin_node_list[len]->alpha;
lattice->set_Z(Z); // alpha of EOS
for (int pos = 0; pos <= static_cast<long>(len); ++pos) {
for (Node *node = begin_node_list[pos]; node; node = node->bnext) {
node->prob = std::exp(node->alpha + node->beta - Z);
for (Path *path = node->lpath; path; path = path->lnext) {
path->prob = std::exp(path->lnode->alpha
- theta * path->cost
+ path->rnode->beta - Z);
}
}
}
return true;
}
bool Viterbi::forwardbackward(const char *sentence, size_t len) {
if (!this->viterbi(sentence, len)) return false;
end_node_list_[0]->alpha = 0.0;
for (int pos = 0; pos <= static_cast<long>(len); ++pos)
for (Node *node = begin_node_list_[pos]; node; node = node->bnext)
calc_alpha(node, theta_);
begin_node_list_[len]->beta = 0.0;
for (int pos = static_cast<long>(len); pos >= 0; --pos)
for (Node *node = end_node_list_[pos]; node; node = node->enext)
calc_beta(node, theta_);
Z_ = begin_node_list_[len]->alpha; // alpha of EOS
for (int pos = 0; pos <= static_cast<long>(len); ++pos)
for (Node *node = begin_node_list_[pos]; node; node = node->bnext)
node->prob = std::exp(node->alpha + node->beta - Z_);
return true;
}
int main(int argc, char* argv[])
{
bool hermite_false, hermite_true;
int n1, n2, npml, pad1, pad2, ns, nw;
float d1, d2, **v, ds, os, dw, ow;
sf_complex ****f, ****obs;
sf_file in, out, misfit, source, receiver, record;
char *order;
int uts, mts, is, i, j, iw, iter, niter;
float **recloc;
float **m_old, **m_new;
float **d_new, **d_old;
float **g_old, **g_new;
sf_complex ****r_new, ****r_old;
sf_complex ****Fg;
float alpha, beta, gnorm, rnorm;
float *datamisfit;
sf_init(argc, argv);
in = sf_input("in");
out = sf_output("out");
misfit = sf_output("misfit");
if (!sf_getint("uts",&uts)) uts=0;
//#ifdef _OPENMP
// mts = omp_get_max_threads();
//#else
mts = 1;
//#endif
uts = (uts < 1)? mts: uts;
hermite_false=false;
hermite_true=true;
/* Hermite operator */
if (!sf_getint("npml",&npml)) npml=20;
/* PML width */
if (!sf_getint("niter",&niter)) niter=0;
/* Number of iterations */
if (NULL == (order = sf_getstring("order"))) order="c";
/* discretization scheme (default optimal 9-point) */
fdprep_order(order);
/* read input dimension */
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input.");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input.");
if (!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input.");
if (!sf_histfloat(in,"d2",&d2)) sf_error("No d2= in input.");
v = sf_floatalloc2(n1,n2);
sf_floatread(v[0],n1*n2,in);
/* PML padding */
pad1 = n1+2*npml;
pad2 = n2+2*npml;
/* read receiver */
if (NULL == sf_getstring("receiver")) sf_error("Need receiver=");
receiver = sf_input("receiver");
recloc=sf_floatalloc2(n1,n2);
sf_floatread(recloc[0],n1*n2,receiver);
/* read source */
if (NULL == sf_getstring("source")) sf_error("Need source=");
source = sf_input("source");
if (!sf_histint(source,"n3",&ns)) sf_error("No ns=.");
if (!sf_histfloat(source,"d3",&ds)) ds=d2;
if (!sf_histfloat(source,"o3",&os)) os=0.;
/* read observed data */
if (NULL == sf_getstring("record")) sf_error("Need record=");
record = sf_input("record");
if (!sf_histint(record,"n4",&nw)) sf_error("No nw=.");
if (!sf_histfloat(record,"d4",&dw)) sf_error("No dw=.");
if (!sf_histfloat(record,"o4",&ow)) sf_error("No ow=.");
f = sf_complexalloc4(n1,n2,ns,nw);
obs = sf_complexalloc4(n1,n2,ns,nw);
sf_complexread(f[0][0][0],n1*n2*ns*nw,source);
sf_complexread(obs[0][0][0],n1*n2*ns*nw,record);
/* allocate variables */
m_old = sf_floatalloc2(n1,n2);
m_new = sf_floatalloc2(n1,n2);
d_old = sf_floatalloc2(n1,n2);
d_new = sf_floatalloc2(n1,n2);
g_old = sf_floatalloc2(n1,n2);
g_new = sf_floatalloc2(n1,n2);
r_old = sf_complexalloc4(n1,n2,ns,nw);
r_new = sf_complexalloc4(n1,n2,ns,nw);
Fg = sf_complexalloc4(n1,n2,ns,nw);
/* set output dimension */
sf_putint(out,"n1",n1);
sf_putint(out,"n2",n2);
sf_putint(out,"n3",niter);
sf_putint(misfit,"n1",niter);
sf_putfloat(misfit,"d1",1);
sf_putint(misfit,"n2",1);
datamisfit = sf_floatalloc(niter);
rnorm = 0.0;
for ( iw = 0; iw < nw; iw ++ ) {
for ( is = 0; is < ns; is ++) {
for ( j = 0; j < n2 ; j++ ) {
for ( i = 0; i < n1; i++ ) {
r_old[iw][is][j][i] = obs[iw][is][j][i];
if ( recloc[j][i] > 0.0 ) {
rnorm += cabsf( r_old[iw][is][j][i] * r_old[iw][is][j][i] );
}
}
}
}
}
sf_warning("rnorm = %g.",rnorm);
sf_warning("Adjoint calculation for the first iteration.");
/* adjoint calculation */
adjlsm_operator(nw, ow, dw, ns, n1, n2,
uts, pad1, pad2, npml, d1, d2,
hermite_false, hermite_true, v, f, recloc,
r_old, g_old);
/* set starting valuables */
for (j = 0; j < n2; j++) {
for (i = 0; i < n2; i++ ) {
d_old[j][i] = g_old[j][i];
m_old[j][i] = 0.0;
}
}
for ( iter = 0; iter < niter; iter ++ ) {
sf_warning("Calculating iteration %d out of %d.",iter,niter);
/* born forward operator */
bornsyn_operator(nw, ow, dw, ns, n1, n2,
uts, pad1, pad2, npml, d1, d2,
hermite_false, v, f, recloc,
d_old, Fg);
/* calculate alpha value */
alpha = calc_alpha(g_old, Fg, recloc, n1, n2, ns, nw);
/* update model */
update_model_lsm(m_old, m_new, d_old, alpha, n1, n2);
/* update residual */
update_residual(r_old, r_new, Fg, recloc, alpha, n1, n2, ns, nw);
/* adjoint operator */
adjlsm_operator(nw, ow, dw, ns, n1, n2,
uts, pad1, pad2, npml, d1, d2,
hermite_false, hermite_true, v, f, recloc,
r_new, g_new);
/* update direction */
beta = direction_cg_fletcher(g_old, d_old, g_new, d_new, n1, n2);
sf_warning("alpha = %g, beta = %g.",alpha, beta);
/* update vectors */
gnorm = 0.0 ;
for (j = 0; j < n2; j++ ) {
for (i = 0; i < n1; i++ ) {
d_old[j][i] = d_new[j][i];
g_old[j][i] = g_new[j][i];
m_old[j][i] = m_new[j][i];
gnorm += g_old[j][i] * g_old[j][i];
}
}
rnorm = 0.0 ;
for (iw = 0; iw < nw; iw ++ ) {
for (is = 0; is < ns; is ++ ) {
for (j = 0; j < n2; j ++ ) {
for (i = 0; i < n1; i ++ ) {
r_old[iw][is][j][i] = r_new[iw][is][j][i];
if ( recloc[j][i] > 0.0 ) {
rnorm += cabsf( r_old[iw][is][j][i] * r_old[iw][is][j][i] );
}
}
}
}
}
sf_warning("gnorm = %g; rnorm = %g.",gnorm, rnorm);
datamisfit[iter] = rnorm;
sf_floatwrite(m_old[0],n1*n2,out);
} /* end iteration */
sf_floatwrite(datamisfit, niter, misfit);
exit(0);
}
int algo()
{
int i, j;
int RWmP[MAX_TASK_NUM];
fscanf(fin, "%d%d%d%d", &true_task_num, &task_num, &processor_num, &lcm_period);
period=(int *)malloc(sizeof(int)*task_num);
execute=(int *)malloc(sizeof(int)*task_num);
w=(float *)malloc(sizeof(float)*task_num);
for(i=0; i<task_num; i++)
fscanf(fin, "%d", &period[i]);
for(i=0; i<task_num; i++)
fscanf(fin, "%d", &execute[i]);
for(i=0; i<task_num; i++)
{
w[i]=((float)execute[i])/((float)period[i]);
RWmP[i]=0;
}
calc_bound();
initialize();
calc_alpha();
calc_UF();
for(i=0; i<processor_num; i++)
for(j=0; j<lcm_period; j++)
alloc[i][j]=-1;
for(i=0; i<row_num; i++)
Bfair(RWmP, i);
/* for(i=0; i<processor_num; i++)
{
for(j=0; j<lcm_period; j++)
{
fprintf(fout, "%d ", alloc[i][j]);
}
fprintf(fout, "\n");
}*/
if(checkSchedule()==-1)
{
printf("!!!Schedule error.\n");
}
else
printf("successfully scheduling.\n");
countPreemption();
countMigration();
countEvent();
fprintf(flog, "preemption:\n");
for(i=0; i<true_task_num; i++)
{
double ppj=((double)preemption[i])/((double)(lcm_period/period[i]));
fprintf(flog, "%lf ", ppj);
}
fprintf(flog, "\n");
fprintf(flog, "migration:\n");
for(i=0; i<true_task_num; i++)
{
double mpj=((double)migration[i])/((double)(lcm_period/period[i]));
fprintf(flog, "%lf ", mpj);
}
fprintf(flog, "\n");
fprintf(flog, "event:\n");
for(i=0; i<true_task_num; i++)
{
double epj=((double)event[i])/((double)(lcm_period/period[i]));
fprintf(flog, "%lf ", epj);
}
fprintf(flog, "\n");
remains();
return 0;
}
int main(int argc,char *argv[])
{
// decode arguments
args(argc,argv);
inits();
if(run_type==6)
to_year=2010;
// Read in Data //
cout<< "Reading Data\n";
read_data();
// Set initial Params //
cout<< "Initiallizing...\n";
init_state();
init_t();
calc_state();
if(fixed_d != 0) //run traf_mat once and only once (for faster prototyping)
{
calc_traf();
/* _vbc_vec<float> Uj(1,n_lakes);
for(int j=1;j<=n_lakes;j++)
{
Uj(j) = 0;
for(int i=1;i<=n_sources;i++)
{
Uj(j) += sources(i).Gij(j) * sources(i).Oi;
}
cout << Uj(j) << "\t" << 1-exp(- pow(0.001 * Uj(j), 1 ) ) << "\n";
}
*/
calc_traf_mat();
calc_pp();
}
ofstream ll_("output/ll_test.dat");
if(FALSE)
{
calc_traf();
calc_traf_mat();
calc_pp(); //!!
int tmp_t;
for(int lake=1;lake<=n_lakes;lake++)
{
if(lakes(lake).invaded == 0 && lakes(lake).last_abs == 0 )
{
for(int t=from_year;t<=to_year+2;t++)
{
// sample_t();
tmp_t=t_vec(lake);
t_vec(lake)=t;
calc_state();
calc_pp();
cout << lake << "\t" << t <<endl;
ll_ << lake << "\t" << t <<"\t"<<l_hood()<<endl;
}
t_vec(lake)=tmp_t;
}
}
}
if(FALSE) // likelihood profile of d and e //if init_t is random, MLE d=e=0 (no effect of distance or size: CHECK)
{
d_par=-1;
e_par=0;
for(int i=0;i<=60;i++)
{
d_par=d_par+0.1;
e_par=0;
for(int j=0;j<=10;j++)
{
e_par=e_par + 0.1;
calc_traf();
calc_traf_mat();
calc_pp();
ll_ << d_par << "\t" << e_par << "\t" << l_hood()<< endl;
cout << d_par <<"\t"<< e_par << "\t" << l_hood()<< endl;
}
}
}
if(FALSE) //likelihood profile of alpha
{
chem_pars(1)=0;
for(int i=0;i<=1000;i++)
{
chem_pars(1)+=0.0001;
ll_ << chem_pars(1) << "\t" << l_hood()<< endl;
}
}
//Just sim under the true alpha to see the t_vec distribution
// to compare with sim_dat.R
if(FALSE)
{
for(int lake_index=1;lake_index<=n_lakes;lake_index++)
{
lakes(lake_index).discovered=0;
lakes(lake_index).last_abs=0;
}
for(int i=1;i<=1000;i++)
{
sim_spread();
write_t();
}
}
/// SEEDS ///
//i d e c B_o NAUT KKUT MGUT
//8394 1.06513 0.531416 0.000125572 -13.713 0.00405104 -0.00475339 0.0038181
// CAUT PPUT1 SIO3UR DOC COLTR ALKTI ALKT
//0.00403173 0.0571088 1.28896 -0.31447 -0.00654376 0.0621327 -0.000480646
// PH COND25 SECCHI.DEPTH NA
//0.00852002 0.00335544 0.0995729 -380.192
//0.407766 1.44137 0.417034 -10.8476 0.708086 -0.0150081 -0.404532 -0.512538 0.689779 0.43177-0.584563 -0.224491 0.786624 1.0269 0.868935 -0.0982729 0.37267
chem_pars(1)=-10;
chem_pars(2)=0.7;
chem_pars(3)=-0.01; //-2:1 MLE ~0
chem_pars(4)=-0.38; //-1.5:1.5 MLE ~0
chem_pars(5)=-0.5; //-0.4:0.2 MLE ~0
chem_pars(6)=0.68; //0:0.1 MLE 0.05 ***
chem_pars(7)=0.43; //-0.4:0.2 MLE ~1.3 ****
chem_pars(8)=-0.58; //-0.7:0.1 MLE ~-0.31 ****
chem_pars(9)=-0.22; //-0.4:0.2 MLE ~-0.01 **
chem_pars(10)=0.78; //-0.1:0.1 MLE ~0.06 *
chem_pars(11)=1.02; //-0.16:0.1 MLE ~0
chem_pars(12)=0.85; //-0.2:0.2 MLE ~0
chem_pars(13)=-0.09; //-0.04:0.01 MLE ~0
chem_pars(14)=0.37; //-0.3:0.3 MLE ~0.1
int test_ch=14;
d_par=1.54;
//float bb = l_hood();
if(ll)
{
float tmplhood;
for(int i=1;i<=20;i++)
{
cerr << i << "\n";
//chem_pars(test_ch)=chem_pars(test_ch)+0.0013;
d_par=d_par+0.05;
calc_traf();
cerr << "A" << "\n";
calc_traf_mat();
cerr << "B" << "\n";
sim_spread();
cerr << "C" << "\n";
//write_t();
tmplhood = l_hood();
cerr << "D" << "\n";
ll_ << chem_pars(test_ch) << "\t" << tmplhood << "\n";
cout << d_par << "\t" << tmplhood << "\n";
}
}
ll_.close();
cout << "# sampled\t" << n_sampled << "\n";
if(run_type==1)
{
// FIT ON TRAF_PARS & SPREAD PARS ONLY (NO ENV) //
// need a likelihood function wrapper to call l_hood() multiple times and average the result
// to smooth out stochastic surface.
// BOOTSTRAP RESAMPLING OF DATA (SAMPLED LAKES) TO GENERATE CI //
float garbage=l_hood();
int n_reps = 1000;
ofstream par_file;
int n_pars; //13 env + intercept + d,c,gamma
_vbc_vec<float> params1;
_vbc_vec<float> dat1;
_vbc_vec<float> MLE_params;
if(!env)
{
if(sim)
par_file.open("sims/gb_output/pred_pars.tab");
else
par_file.open("output/pred_pars.tab");
n_pars=4; // d,c,gamma,alpha
params1.redim(1,n_pars);
dat1.redim(1,n_pars);
MLE_params.redim(1,n_pars);
params1(1)=1.27;
params1(2)=1.48;
params1(3)=0.0000489;
params1(4)=0.00105;
}else{
if(sim)
par_file.open("sims/gb_output/pred_parsENV.tab");
else
par_file.open("output/pred_parsENV.tab");
n_pars=18; //13 env + intercept + d,e,c,gamma
params1.redim(1,n_pars);
dat1.redim(1,n_pars);
MLE_params.redim(1,n_pars);
params1(1)=1.79;
params1(2)=2;
params1(3)=0.69;
params1(4)=0.0000489;
/// SEEDS ///
params1(5)=-6.2;
params1(6)=0.014;
params1(7)=-0.08; //-2:1 MLE ~0
params1(8)=0.15; //-1.5:1.5 MLE ~0
params1(9)=0.21; //-0.4:0.2 MLE ~0
params1(10)=0.03; //0:0.1 MLE 0.05 ***
params1(11)=-0.13; //-0.4:0.2 MLE ~1.3 ****
params1(12)=-0.43; //-0.7:0.1 MLE ~-0.31 ****
params1(13)=-0.007; //-0.4:0.2 MLE ~-0.01 **
params1(14)=0.056; //-0.1:0.1 MLE ~0.06 *
params1(15)=0.0087; //-0.16:0.1 MLE ~0
params1(16)=0.081; //-0.2:0.2 MLE ~0
params1(17)=-0.015; //-0.04:0.01 MLE ~0
params1(18)=0.013; //-0.3:0.3 MLE ~0.1
}
_vbc_vec<int> tmp_index_sampled;
tmp_index_sampled = sampled_index;
if(boot)
{
ofstream boot_file;
if(sim)
boot_file.open("sims/gb_output/boot_lakes.tab");
else
boot_file.open("output/boot_lakes.tab");
for(int i=1;i<=n_reps;i++)
{
//Bootstrap resample //
sampled_index = sample_w_replace(tmp_index_sampled);
for(int j=1;j<=n_sampled;j++)
boot_file << sampled_index(j) << "\t";
boot_file << "\n";
boot_file.flush();
// --- //
simplex::clsSimplex<float> gertzen_rep;
//gertzen_rep.set_param_small(1e-3);
gertzen_rep.start(&dat1,¶ms1, &MLE_l_hood,n_pars, 1e-2);
gertzen_rep.getParams(&MLE_params);
cout << "\n\nMLE "<< i << " of " << n_reps << "\n\n";
for(int p=1;p<=n_pars;p++)
par_file << MLE_params(p) <<"\t";
par_file << "\n";
par_file.flush();
}
boot_file.close();
}else{
simplex::clsSimplex<float> gertzen_rep;
//gertzen_rep.set_param_small(1e-3);
gertzen_rep.start(&dat1,¶ms1, &MLE_l_hood,n_pars, 1e-2);
gertzen_rep.getParams(&MLE_params);
cout << "\n\nMLE\n";
for(int p=1;p<=n_pars;p++)
par_file << MLE_params(p) <<"\t";
par_file << "\n";
par_file.flush();
// Print out distribution of alpha values at MLE
ofstream alphas_file;
alphas_file.open("output/alphas.tab",std::fstream::app);
for(int i=1;i<=n_lakes;i++)
{
alphas_file << calc_alpha(i) << "\n";
}
alphas_file.close();
}
par_file.close();
}
if(run_type==2)
{
//MCMC lib
string mcmc_file("output/lib.mcmc");
if(env)
{
_vbc_vec<float> params(1,4+n_chem_var);
_vbc_vec<float> prop_width(1,4+n_chem_var,1,4+n_chem_var);
prop_width(1)=0.05;
prop_width(2)=0.05;
prop_width(3)=0.05;
params(1)=0.4;
params(2)=1.4;
params(3)=0.42;
for(int i=1;i<=n_chem_var+1;i++)
{
prop_width(i+3)=0.0001;
params(i+3)=chem_pars(i);
}
prop_width(4)=0.1;
_vbc_vec<float> prop_sigma;
prop_sigma = diag(prop_width);
// Print out prop_sigma
for(int i=1;i<=n_chem_var+4;i++)
{
for(int j=1;j<=n_chem_var+4;j++)
cout << prop_sigma(i,j) << " | ";
cout << "\n";
}
mcmcMD::run_mcmc(params,
prop_sigma,
&likelihood_wrapperMCMC_MD,
&prior_MD,
&restrict_MCMC_MD,
50000,
50,
1,
mcmc_file.c_str(),
true,
true,
true,
500,
4);
}else
{
/// No env.
_vbc_vec<float> params(1,4);
_vbc_vec<float> prop_width(1,4,1,4);
prop_width(1)=0.05;
prop_width(2)=0.05;
prop_width(3)=0.000001;
prop_width(4)=0.00001;
params(1)=1.27;
params(2)=1.48;
params(3)=0.0000489;
params(4)=0.00105;
_vbc_vec<float> prop_sigma;
prop_sigma = diag(prop_width);
// Print out prop_sigma
for(int i=1;i<=4;i++)
{
for(int j=1;j<=4;j++)
cout << prop_sigma(i,j) << " | ";
cout << "\n";
}
mcmcMD::run_mcmc(params,
prop_sigma,
&likelihood_wrapperMCMC_MD,
&prior_MD,
&restrict_MCMC_MD,
500000,
1,
1,
mcmc_file.c_str(),
true,
true,
true,
500,
5);
}
/* mcmcMD::run_mcmc(pms,
props,
&like,
&prior,
&restrictions,
500000,
1,
100,
file_name.c_str(),
TRUE,
TRUE,
1000);
*/
}
/// Sim from posterior ///
if(run_type==3)
sim_spread_posterior();
/// Traf tests ////
if(run_type==4)
{
ofstream traf_ll_file("output/traf_ll.dat");
d_par=1.54;
e_par=2;
c_par=0.8;
calc_traf();
calc_traf_mat();
calc_pp();
sim_spread();
cout << l_hood() <<"\n";
/*
for(int i=1;i<=70;i++)
{
e_par=e_par+0.05;
cout << e_par << "\t";
calc_traf();
calc_traf_mat();
calc_pp();
sim_spread();
traf_ll_file << e_par << "\t" << l_hood() << "\n";
cout << l_hood() <<"\t";
sim_spread();
traf_ll_file << e_par << "\t" << l_hood() << "\n";
cout << l_hood() <<"\t";
sim_spread();
traf_ll_file << e_par << "\t" << l_hood() << "\n";
cout << l_hood() <<"\n";
traf_ll_file << e_par << "\t" << l_hood() << "\n";
}
for(int i=1;i<=10;i++)
{
e_par=e_par+0.2;
c_par=0.8;
calc_traf();
calc_traf_mat();
calc_pp();
for(int j = 1;j<=10;j++)
{
c_par=c_par+0.2;
glb_alpha=0; //from MLE
for(int k=1;k<=500;k++)
{
glb_alpha=glb_alpha+0.00001;
sim_spread();
sim_spread();
sim_spread();
cout << e_par << "\t" << c_par << "\t" << glb_alpha << "\t" << l_hood() << "\n";
traf_ll_file << e_par << "\t" << c_par << "\t" << glb_alpha << "\t" << l_hood() << "\n";
}
}
}
*/
traf_ll_file.close();
calc_pp();
write_pp();
write_inv_stat();
}
/// Holdout sets for internal AUC ////
if(run_type==5)
{
int n_pars=4;
_vbc_vec<float>params1(1,n_pars);
// Read parameters values from file //
ifstream pred_pars;
if(sim)
pred_pars.open("sims/gb_output/pred_pars.tab");
else
pred_pars.open("output/pred_pars.tab");
for(int j=1;j<=n_pars;j++)
pred_pars >> params1(j);
pred_pars.close();
// -- //
d_par=params1(1);
e_par = 1;
c_par=params1(2);
gamma_par=params1(3);
glb_alpha=params1(4);
calc_traf();
calc_traf_mat();
//write_traf_mat();
//Sub-sample a holdout set from sampled lakes (pre-2010)
int n_sub_sampled = 100,choose_from=0;
_vbc_vec<int> index_2006_big(1,n_lakes);
for(int i = 1; i<=n_lakes;i++)
{
if( (lakes(i).last_abs==2006 || lakes(i).discovered == 2006) )
{
choose_from += 1;
index_2006_big(choose_from)=i;
}
}
_vbc_vec<int> index_2006(1,choose_from);
for(int i = 1; i<=choose_from;i++)
index_2006(i)=index_2006_big(i);
ofstream prop_holdout_file;
prop_holdout_file.open("output/holdout_sim_props.csv");
ofstream holdout_inv_file("output/holdout2006_data_status.csv");
_vbc_vec<int> holdout_inv_status(1,n_sub_sampled);
_vbc_vec<int> indicies_holdout(1,n_sub_sampled);
_vbc_vec<int> tmp_discovered(1,n_sub_sampled);
_vbc_vec<int> tmp_last_abs(1,n_sub_sampled);
cout << "Total 2006 lakes to choose from " << choose_from << "\n";
for(int rep=1;rep<=50;rep++)
{
indicies_holdout = sample_wo_replace(index_2006,n_sub_sampled);
//Record the year_discovered of holdoutset
for(int i = 1; i<=n_sub_sampled;i++)
{
if(lakes(indicies_holdout(i)).discovered == 2006)
holdout_inv_status(i) = 1;
else
holdout_inv_status(i) = 0;
//write year discovered
if(i == n_sub_sampled)
holdout_inv_file << holdout_inv_status(i) << "\n";
else
holdout_inv_file << holdout_inv_status(i) << ",";
//save last_abs and discoved
tmp_discovered(i) = lakes(indicies_holdout(i)).discovered;
tmp_last_abs(i) = lakes(indicies_holdout(i)).last_abs;
//remove year discovered
lakes(indicies_holdout(i)).discovered = 0;
lakes(indicies_holdout(i)).last_abs = 0;
}
//SIM SPREAD
_vbc_vec<float> prop_holdout_invaded(1,n_sub_sampled);
for(int i=1;i<=n_sub_sampled;i++)
prop_holdout_invaded(i) = 0;
int n_sims=1000;
for(int s=1; s<= n_sims; s++)
{
sim_spread();
for(int i=1;i<=n_sub_sampled;i++)
{
if(t_vec(indicies_holdout(i)) <= 2006)
prop_holdout_invaded(i) += 1;
}
}
//write prop inv
for(int i=1;i<=n_sub_sampled;i++)
{
prop_holdout_invaded(i) = prop_holdout_invaded(i)/n_sims;
if(i < n_sub_sampled)
prop_holdout_file << prop_holdout_invaded(i) << ",";
else
prop_holdout_file << prop_holdout_invaded(i) << "\n";
//reset last_abs and discoved
lakes(indicies_holdout(i)).discovered = tmp_discovered(i);
lakes(indicies_holdout(i)).last_abs = tmp_last_abs(i);
}
}
holdout_inv_file.close();
prop_holdout_file.close();
}
int main(){
int i, j, iter,isource,idir,step,irec;
clock_t start = clock();
setbuf(stdout,NULL);
/*** Initial Condition ***/
init();
printf("Start calculation\n");
/*** Calculating for iteratively ***/
for(iter=0;iter<MAXITR;iter++){
printf("%03d th iterative\n",iter);
media_coeff_3d();
init_iterate();
init_FILE3(iter);
//*********** Start backward calculation **********//
for(irec=0;irec<rec_num;irec++){
for(idir=0;idir<NDIRECT;idir++){
banner1(idir,irec);
set_zero_eh();
/*** Calculating for step ***/
for(step=0;step<it-1;step++){
backpropagation(idir, irec, step);
copytoEcal_b(EX,EY,EZ,step,idir, irec,ofe1,ofe2,ofe3);
if(step%(it/20)==it/20-1) printf("#");
}
printf("\n");
laplaceToFreq_back(irec,idir);
output_backwave(irec,idir);
} // END loop for direction
}// END loop for ireceiver
close_FILE3();
//*********** Start of FWD calculation **********//
/*** Calculating for each source ***/
for(isource=0;isource<shot_num;isource++){
printf("This is %2d loop for Transmitter \n",isource);
read_Eobs(isource); // Read observed value of Ex
//init_FILE2(isource, iter);
printf("[PROGRESS =>] ");
set_zero_eh();
media_coeff_3d();
/*** Calculating for step ***/
for(step=0;step<it-1;step++){
fwdpropagation(isource, step);
copytoEcal(EX,EY,EZ,step);
if(step%(it/20)==it/20-1) printf("#");
} // END loop for step
laplaceToFreq_2(isource);
output_fwdwave(isource);
//close_FILE2();
// Calculation of residual error
residualE(iter);
sensitivity();
// Convolution of Greenfunc and conjugated delE
conv_GdelE();
// Calculation of gamma
calc_gamma();
} // END loop for isource
// Calclulation of delta model
calc_phi();
//printf("sig2 %e\n",sig[0]);
media_coeff_sig_tmp();
//*********** again FWD calculation **********//
for(isource=0;isource<shot_num;isource++){
printf("This is %2d loop for AGAIN Transmitter \n",isource);
printf("[PROGRESS =>] ");
set_zero_eh();
/*** Calculating for step ***/
for(step=0;step<it-1;step++){
fwdpropagation(isource, step);
copytoEcal(EX,EY,EZ,step);
if(step%(it/20)==it/20-1) printf("#");
} // END loop for step
laplaceToFreq_3();
calc_alpha(isource);
} // END loop for isource
update_para2(iter);
show_error(iter);
} // END loop for iter
printf("\n");
printf("%f [s] \n",(double)(clock()-start)/CLOCKS_PER_SEC);
fclose(ofer);
}
