/**
* Set up MPI and establish number of processes and rank
*/
void
nest::Communicator::init( int* argc, char** argv[] )
{
/* Initialize MPI
MPI_Init sets the working directory on all machines to the
directory from which mpirun was called. This is usually what one
intends.
On some machines, eg Linux, executables compiled with MPI can be
called without mpirun. MPI_Init will then place NEST in the
directory containing the NEST binary. This is a user error: if
compiled with mpi, nest must be run using mpirun or equivalent.
Unfortunately, there seems to be no straightforward way to check
if nest was started through mpirun.
HEP,MD,AM 2006-08-04
*/
int init;
MPI_Initialized( &init );
int provided_thread_level;
if ( init == 0 )
{
#ifdef HAVE_MUSIC
music_setup = new MUSIC::Setup( *argc, *argv, MPI_THREAD_FUNNELED, &provided_thread_level );
// get a communicator from MUSIC
comm = music_setup->communicator();
#else /* #ifdef HAVE_MUSIC */
MPI_Init_thread( argc, argv, MPI_THREAD_FUNNELED, &provided_thread_level );
comm = MPI_COMM_WORLD;
#endif /* #ifdef HAVE_MUSIC */
}
MPI_Comm_size( comm, &num_processes_ );
MPI_Comm_rank( comm, &rank_ );
recv_buffer_size_ = send_buffer_size_ * num_processes_;
// create off-grid-spike type for MPI communication
// creating derived datatype
OffGridSpike::assert_datatype_compatibility();
MPI_Datatype source_types[ 2 ];
int blockcounts[ 2 ];
MPI_Aint offsets[ 2 ];
MPI_Aint start_address, address;
OffGridSpike ogs( 0, 0.0 );
// OffGridSpike.gid
offsets[ 0 ] = 0;
source_types[ 0 ] = MPI_DOUBLE;
blockcounts[ 0 ] = 1;
// OffGridSpike.offset
MPI_Address( &( ogs.gid_ ), &start_address );
MPI_Address( &( ogs.offset_ ), &address );
offsets[ 1 ] = address - start_address;
source_types[ 1 ] = MPI_DOUBLE;
blockcounts[ 1 ] = 1;
// generate and commit struct
MPI_Type_struct( 2, blockcounts, offsets, source_types, &MPI_OFFGRID_SPIKE );
MPI_Type_commit( &MPI_OFFGRID_SPIKE );
initialized_ = true;
}
void function_minimizer::pvm_master_mcmc_routine(int nmcmc,int iseed0,double dscale,
int restart_flag)
{
uostream * pofs_psave=NULL;
dmatrix mcmc_display_matrix;
int mcmc_save_index=1;
int mcmc_wrap_flag=0;
int mcmc_gui_length=10000;
int no_sd_mcmc=0;
int on2=-1;
if ( (on2=option_match(ad_comm::argc,ad_comm::argv,"-nosdmcmc"))>-1)
no_sd_mcmc=1;
if (stddev_params::num_stddev_params==0)
{
cerr << " You must declare at least one object of type sdreport "
<< endl << " to do the mcmc calculations" << endl;
return;
}
{
//ofstream of_bf("testbf");
//if (adjm_ptr) set_labels_for_mcmc();
ivector number_offsets;
dvector lkvector;
//double current_bf=0;
double lcurrent_bf=0;
double size_scale=1.0;
double total_spread=200;
//double total_spread=2500;
uostream * pofs_sd = NULL;
int nvar=initial_params::nvarcalc(); // get the number of active parameters
int scov_option=0;
dmatrix s_covar;
dvector s_mean;
int on=-1;
int ncsim=25000;
int nslots=800;
//int nslots=3600;
int initial_nsim=4800;
int ntmp=0;
int ncor=0;
double bfsum=0;
int ibfcount=0;
double llbest;
double lbmax;
//if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcscov",ntmp))>-1)
//{
scov_option=1;
s_covar.allocate(1,nvar,1,nvar);
s_mean.allocate(1,nvar);
s_mean.initialize();
s_covar.initialize();
int ndvar=stddev_params::num_stddev_calc();
int numdvar=stddev_params::num_stddev_number_calc();
/*
if (adjm_ptr)
{
mcmc_display_matrix.allocate(1,numdvar,1,mcmc_gui_length);
number_offsets.allocate(1,numdvar);
number_offsets=stddev_params::copy_all_number_offsets();
}
*/
dvector x(1,nvar);
dvector scale(1,nvar);
dmatrix values;
int have_hist_flag=0;
initial_params::xinit(x);
dvector pen_vector(1,nvar);
{
initial_params::reset(dvar_vector(x),pen_vector);
cout << pen_vector << endl << endl;
}
initial_params::mc_phase=0;
initial_params::stddev_scale(scale,x);
initial_params::mc_phase=1;
dvector bmn(1,nvar);
dvector mean_mcmc_values(1,ndvar);
dvector s(1,ndvar);
dvector h(1,ndvar);
//dvector h;
dvector square_mcmc_values(1,ndvar);
square_mcmc_values.initialize();
mean_mcmc_values.initialize();
bmn.initialize();
int use_empirical_flag=0;
int diag_option=0;
int topt=0;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcdiag"))>-1)
{
diag_option=1;
cout << " Setting covariance matrix to diagonal with entries " << dscale
<< endl;
}
dmatrix S(1,nvar,1,nvar);
dvector sscale(1,nvar);
if (!diag_option)
{
int on,nopt;
int rescale_bounded_flag=0;
double rescale_bounded_power=0.5;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcrb",nopt))>-1)
{
if (nopt)
{
int iii=atoi(ad_comm::argv[on+1]);
if (iii < 1 || iii > 9)
{
cerr << " -mcrb argument must be integer between 1 and 9 --"
" using default of 5" << endl;
rescale_bounded_power=0.5;
}
else
rescale_bounded_power=iii/10.0;
}
else
{
rescale_bounded_power=0.5;
}
rescale_bounded_flag=1;
}
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcec"))>-1)
{
use_empirical_flag=1;
}
if (use_empirical_flag)
{
read_empirical_covariance_matrix(nvar,S,ad_comm::adprogram_name);
}
else if (!rescale_bounded_flag)
{
int tmp;
read_covariance_matrix(S,nvar,tmp,sscale);
}
else
{
read_hessian_matrix_and_scale1(nvar,S,rescale_bounded_power,
mcmc2_flag);
//read_hessian_matrix_and_scale(nvar,S,pen_vector);
}
{ // scale covariance matrix for model space
dmatrix tmp(1,nvar,1,nvar);
for (int i=1;i<=nvar;i++)
{
tmp(i,i)=S(i,i)*(scale(i)*scale(i));
for (int j=1;j<i;j++)
{
tmp(i,j)=S(i,j)*(scale(i)*scale(j));
tmp(j,i)=tmp(i,j);
}
}
S=tmp;
}
}
else
{
S.initialize();
for (int i=1;i<=nvar;i++)
{
S(i,i)=dscale;
}
}
cout << sort(eigenvalues(S)) << endl;
dmatrix chd = choleski_decomp( (dscale*2.4/sqrt(double(nvar))) * S);
dmatrix chdinv=inv(chd);
int sgn;
dmatrix symbds(1,2,1,nvar);
initial_params::set_all_simulation_bounds(symbds);
ofstream ofs_sd1((char*)(ad_comm::adprogram_name + adstring(".mc2")));
{
long int iseed=0;
int number_sims;
if (nmcmc<=0)
{
number_sims= 100000;
}
else
{
number_sims= nmcmc;
}
//cin >> iseed;
if (iseed0<=0)
{
iseed=-36519;
}
else
{
iseed=-iseed0;
}
if (iseed>0)
{
iseed=-iseed;
}
cout << "Initial seed value " << iseed << endl;
random_number_generator rng(iseed);
rng.better_rand();
//better_rand(iseed);
double lprob=0.0;
double lpinv=0.0;
double lprob3=0.0;
// get lower and upper bounds
independent_variables y(1,nvar);
independent_variables parsave(1,nvar);
// read in the mcmc values to date
int ii=1;
dmatrix hist;
if (restart_flag)
{
int tmp=0;
if (!no_sd_mcmc) {
hist.allocate(1,ndvar,-nslots,nslots);
tmp=read_hist_data(hist,h,mean_mcmc_values,s,parsave,iseed,
size_scale);
values.allocate(1,ndvar,-nslots,nslots);
for (int i=1;i<=ndvar;i++)
{
values(i).fill_seqadd(mean_mcmc_values(i)-0.5*total_spread*s(i)
+.5*h(i),h(i));
}
}
if (iseed>0)
{
iseed=-iseed;
}
double br=rng.better_rand();
if (tmp) have_hist_flag=1;
chd=size_scale*chd;
chdinv=chdinv/size_scale;
}
else
{
int on=-1;
int nopt=0;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcpin",nopt))>-1)
{
if (nopt)
{
cifstream cif((char *)ad_comm::argv[on+1]);
if (!cif)
{
cerr << "Error trying to open mcmc par input file "
<< ad_comm::argv[on+1] << endl;
exit(1);
}
cif >> parsave;
if (!cif)
{
cerr << "Error reading from mcmc par input file "
<< ad_comm::argv[on+1] << endl;
exit(1);
}
}
else
{
cerr << "Illegal option with -mcpin" << endl;
}
}
else
{
ii=1;
initial_params::copy_all_values(parsave,ii);
}
}
ii=1;
initial_params::restore_all_values(parsave,ii);
gradient_structure::set_NO_DERIVATIVES();
ofstream ogs("sims");
ogs << nvar << " " << number_sims << endl;
initial_params::xinit(y);
send_int_to_slaves(1);
double llc=-pvm_master_get_monte_carlo_value(nvar,y);
send_int_to_slaves(1);
llbest=-pvm_master_get_monte_carlo_value(nvar,y);
lbmax=llbest;
// store current mcmc variable values in param_values
//dmatrix store_mcmc_values(1,number_sims,1,ndvar);
#if defined(USE_BAYES_FACTORS)
lkvector.allocate(1,number_sims);
#endif
dvector mcmc_values(1,ndvar);
dvector mcmc_number_values;
//if (adjm_ptr) mcmc_number_values.allocate(1,numdvar);
int offs=1;
stddev_params::copy_all_values(mcmc_values,offs);
/*
if (adjm_ptr)
{
offs=1;
stddev_params::copy_all_number_values(mcmc_number_values,offs);
}
*/
int change_ball=2500;
int nopt;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcscale",nopt))>-1)
{
if (nopt)
{
int iii=atoi(ad_comm::argv[on+1]);
if (iii <=0)
{
cerr << " Invalid option following command line option -mcball -- "
<< endl << " ignored" << endl;
}
else
change_ball=iii;
}
}
int iac=0;
int liac=0;
int isim=0;
int itmp=0;
double logr;
int u_option=0;
double ll;
int s_option=1;
int psvflag=0;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcu"))>-1)
{
u_option=1;
}
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcnoscale"))>-1)
{
s_option=0;
}
//cout << llc << " " << llc << endl;
int iac_old=0;
int i_old=0;
{
if (!restart_flag)
{
pofs_sd =
new uostream((char*)(ad_comm::adprogram_name + adstring(".mcm")));
}
int mcsave_flag=0;
int mcrestart_flag=option_match(ad_comm::argc,ad_comm::argv,"-mcr");
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcsave"))>-1)
{
int jj=(int)atof(ad_comm::argv[on+1]);
if (jj <=0)
{
cerr << " Invalid option following command line option -mcsave -- "
<< endl;
}
else
{
mcsave_flag=jj;
if ( mcrestart_flag>-1)
{
// check that nvar is correct
{
uistream uis((char*)(ad_comm::adprogram_name + adstring(".psv")));
if (!uis)
{
cerr << "Error trying to open file" <<
ad_comm::adprogram_name + adstring(".psv") <<
" for mcrestart" << endl;
cerr << " I am starting a new file " << endl;
psvflag=1;
}
else
{
int nv1;
uis >> nv1;
if (nv1 !=nvar)
{
cerr << "wrong number of independent variables in" <<
ad_comm::adprogram_name + adstring(".psv") <<
cerr << " I am starting a new file " << endl;
psvflag=1;
}
}
}
if (!psvflag) {
pofs_psave=
new uostream(
(char*)(ad_comm::adprogram_name + adstring(".psv")),ios::app);
} else {
pofs_psave=
new uostream((char*)(ad_comm::adprogram_name + adstring(".psv")));
}
} else {
