/** \brief save Array-struct as MATLAB .mat file.
Currently, the function converts all arrays to
double-arrays. Should be easy to implement for arbitrary types if
needed.
\param a the Array
\param varname MATLAB-name of the array
\param file the filename
\param append if TRUE, the function tries to open() the file, else it is overwritten
\return error code
*/
int write_array_matlab( const Array *a, const char *varname, const char *file, bool append ){
mat_t *mfile;
matvar_t *marr=NULL;
int i;
if( append ){
if( !(mfile=Mat_Open( file, MAT_ACC_RDWR )) ){
errprintf("Could not open '%s', creating new file\n", file);
}
}
if( !mfile ){
if( !(mfile=Mat_Create( file, NULL )) ){
errprintf("Could not open '%s' for writing\n", file);
return -1;
}
}
int ndim = MAX(2, a->ndim);
int *size = (int*)malloc( ndim*sizeof(int));
if( a->ndim==1 ){
size[0]=1;
size[1]=a->size[0];
} else {
memcpy( size, a->size, ndim*sizeof(int));
}
dprintf("Writing to file '%s' variable '%s', ndim=%i\n", file, varname, ndim);
/* convert to column major for MATLAB */
Array *b=array_convert_rowcolmajor( (Array*)a, TRUE );
dprintf("Up-cast, b->ndim=%i, b->size=%p, b->size[0]=%i\n", b->ndim, b->size, b->size[0]);
/* up-cast to DOUBLE - copy of b */
Array *c=array_new( DOUBLE, b->ndim, b->size );
dprintf("casting\n");
for( i=0; i<array_NUMEL(b); i++ ){
array_dtype_to_double( array_INDEXMEM1(c,i), array_INDEXMEM1(b,i), b->dtype );
}
array_free( b );
dprintf("Creating MATLAB-rep\n");
marr = Mat_VarCreate( varname, MAT_C_DOUBLE, MAT_T_DOUBLE,
ndim, size, c->data, MEM_CONSERVE /* Array remains owner */
);
dprintf("mfile=%p, marr=%p, rank=%i,\n", mfile, marr, marr->rank );
int succ=Mat_VarWrite( mfile, marr, 0 );
dprintf("done writing with succ=%i\n", succ);
Mat_Close( mfile );
Mat_VarFree( marr );
array_free( c );
free( size );
return 0;
}
/*
* matWrite - write signals from measurement structure to MAT file
*/
int matWrite(measurement_t *measurement, const char *outFileName)
{
size_t dims[2];
int err = 0;
mat_t *mat;
matvar_t *matvar;
mat = Mat_Create(outFileName, NULL);
if (mat != NULL) {
/* loop over all time series */
struct hashtable *timeSeriesHash = measurement->timeSeriesHash;
/* Iterator constructor only returns a valid iterator if
* the hashtable is not empty */
if (hashtable_count(timeSeriesHash) > 0) {
struct hashtable_itr *itr = hashtable_iterator(timeSeriesHash);
do {
char *signalName = hashtable_iterator_key(itr);
timeSeries_t *timeSeries = hashtable_iterator_value(itr);
double *timeValue = (double *)malloc(sizeof(double)*2*timeSeries->n);
unsigned int i;
/*
* build up a 1x2n array with time stamps in [0..n-1] and
* values in [n..2n-1].
*/
for(i=0;i<timeSeries->n;i++) {
timeValue[i] = timeSeries->time[i];
}
for(i=0;i<timeSeries->n;i++) {
timeValue[timeSeries->n + i] = timeSeries->value[i];
}
dims[0] = timeSeries->n;
dims[1] = 2;
/* output signal to mat structure and free up temp array. */
matvar = Mat_VarCreate(signalName, MAT_C_DOUBLE, MAT_T_DOUBLE,
2, dims, timeValue, 0);
Mat_VarWrite(mat, matvar, 0);
Mat_VarFree(matvar);
free(timeValue);
} while (hashtable_iterator_advance(itr));
free(itr);
}
Mat_Close(mat);
} else {
fprintf(stderr, "error: could not create MAT file %s\n", outFileName);
err = 1;
}
return err;
}
// save a .mat matlab matrix
// will store a single matrix (sparse or dense) in a .mat file
// returns 0 on success
static
int write_mat(char const *const filename,
matrix_t *const A) {
#ifndef HAVE_MATIO
return 1;
#else
const char created_by[] = "created by " PACKAGE_STRING; // "created by Meagre-Crowd x.y.z"
mat_t* matfp;
matfp = Mat_Create(filename, created_by);
if(matfp == NULL)
return 1; // failed to open file
// create a matrix convert into
matvar_t* t = NULL;
int ret = 0;
if(A->format == DCOL || A->format == DROW) { // dense
ret = convert_matrix(A, DCOL, FIRST_INDEX_ZERO); // DROW -> DCOL if DROW
if(ret != 0)
ret = 2; // conversion failure
if(ret == 0) {
// TODO check for integer overflow in cast from unsigned int -> int
size_t dims[] = { A->m, A->n };
t = Mat_VarCreate( "x",
MAT_C_DOUBLE,
MAT_T_DOUBLE,
2, // always at least rank 2
dims,
A->dd,
0 // MAT_F_COMPLEX if complex, could avoid copying data: MAT_F_DONT_COPY_DATA if not sparse
);
if(t == NULL) {
ret = 3; // failed to malloc data for storage
}
else {
ret = Mat_VarWrite(matfp, t, 1); // compress
if(ret != 0)
ret = 4; // failed data write
}
}
}
else { // sparse
assert(0); // do we ever get sparse results?
}
Mat_Close(matfp);
Mat_VarFree(t);
return ret; // success?
#endif
}
/** \brief write EEG-struct to EEGlab-compatible MATLAB file.
This write uses MatIO to create an EEGlab file.
It was developed with EEGlab version 6.01b.
\todo NOT IMPLEMENTED!
\param eeg the struct
\param file eeglab .set file
\return error code
*/
int write_eeglab_file( EEG* eeg, const char *file ){
mat_t *mfile;
matvar_t *meeg=NULL;
if( !(mfile=Mat_Create( file, NULL )) ){
errprintf("Could not open '%s' for writing\n", file);
return -1;
}
//int dims[2]={1,1}, rank=2;
//meeg = Mat_VarCreate( "EEG", MAT_T_STRUCT, , rank, dims, NULL, 0 );
Mat_VarWrite( mfile, meeg, 0 );
return 0;
}
int main(int argn, char **argc){
if(argn != 3){
printf("usage: convert infile.bin outfile.mat\n");
exit(0);
} else {
FILE* in = fopen(argc[1], "r");
if(!in) {
printf("could not open %s\n", argc[1]);
exit(0);
}
mat_t *mat;
mat = Mat_Create(argc[2],NULL);
if(!mat){
printf("could not open for writing %s\n", argc[2]);
exit(0);
}
//this is (for now) a two-stage process:
//have to scan through the file,
//determine what's there, allocate memory appropritately,
//then fill those structures up and write *that* out.
unsigned int u;
unsigned int pos = 0;
unsigned int rxpackets = 0;
unsigned int txpackets = 0;
unsigned int msgpackets = 0;
bool done = false;
while(!done){
fread((void*)&u,4,1,in);
if(ferror(in) || feof(in)) done = true;
else {
if(u == 0xdecafbad){
fread((void*)&u,4,1,in);
unsigned int siz = u & 0xffff;
//printf("u 0x%x\n",u);
rxpackets += (siz-4)/(32+4);
fseek(in,siz+8, SEEK_CUR);
pos += 16+siz;
}else if(u == 0xc0edfad0){
fread((void*)&u,4,1,in);
unsigned int siz = u & 0xffff;
//printf("u 0x%x\n",u);
txpackets++;
fseek(in,siz+8, SEEK_CUR);
pos += 16+siz;
}else if(u == 0xb00a5c11){
fread((void*)&u,4,1,in);
unsigned int siz = u & 0xffff;
//printf("u 0x%x\n",u);
msgpackets += 1;
fseek(in,siz+8, SEEK_CUR);
pos += 16+siz;
} else {
printf("magic number seems off, is 0x%x, %d bytes, %d packets\n",
u,pos,rxpackets);
exit(0);
}
if(ferror(in) || feof(in)) done = true;
}
}
printf("total %d rxpackets, %d txpackets, %d messages\n",
rxpackets, txpackets, msgpackets);
fseek(in,0, SEEK_SET);
//okay, allocate appropriate data structs:
// time (double), analog(i8), channel (i8),
// spike_time (double), spikes(i32)
double* time;
mat_uint32_t* mstimer;
mat_int8_t* analog;
mat_int8_t* channel;
mat_uint32_t* spike_ts;
mat_int8_t* spike_ch;
mat_int8_t* spike_unit;
// store timestamp (in samples), rx time (not necessarily accurate) - one per pkt
// store channel # and sample
// store channel & timestamp for spikes.
// just ignore dropped packets for now.
time = (double*)malloc(rxpackets * sizeof(double));
if(!time){ printf("could not allocate time variable."); exit(0);}
mstimer = (mat_uint32_t*)malloc(rxpackets * sizeof(int) );
if(!mstimer){ printf("could not allocate mstimer variable."); exit(0);}
analog = (mat_int8_t*)malloc(rxpackets * 24 );
if(!analog){ printf("could not allocate analog variable."); exit(0);}
channel = (mat_int8_t*)malloc(rxpackets * 24 );
if(!channel){ printf("could not allocate channel variable."); exit(0);}
spike_ts = (mat_uint32_t*)malloc(rxpackets * sizeof(int)*32);
if(!spike_ts){ printf("could not allocate spike_ts variable."); exit(0);}
spike_ch = (mat_int8_t*)malloc(rxpackets * 32);
if(!spike_ch){ printf("could not allocate spike_ch variable."); exit(0);}
spike_unit = (mat_int8_t*)malloc(rxpackets * 32);
if(!spike_unit){ printf("could not allocate spike_unit variable."); exit(0);}
//also need to inspect the messages, to see exactly when the channels changed.
rxpackets = 0;
int tp = 0; // packet position (index time, aka timestamp)
int sp = 0; // spike position (index spike variables)
char msgs[16][128]; //use this to save messages ; appy them when their echo appears.
for(int i=0; i<16*128; i++){
msgs[0][i] = 0; //yes, you can do that in c!
}
int chans[4] = {0,32,64,96};
done = false;
while(!done){
fread((void*)&u,4,1,in);
if(ferror(in) || feof(in)) done = true;
else {
if(u == 0xdecafbad){
fread((void*)&u,4,1,in);
unsigned int siz = u & 0xffff;
int npak = (siz-4)/(4+32);
//first 4 is for dropped packet count
//second 4 is for 4 byte bridge milisecond counter
//printf("npak %d siz %d\n",npak,siz);
double rxtime = 0.0;
unsigned int dropped = 0;
fread((void*)&rxtime,8,1,in); //rx time in seconds.
fread((void*)&dropped,4,1,in);
int channels[32]; char match[32];
for(int i=0;i<npak; i++){
packet p;
fread((void*)&p,sizeof(p),1,in);
if(ferror(in) || feof(in)) done = true;
else{
/*int headecho = ((p.flag) >> 4) & 0xf;
//check to see if we can apply the command that was echoed.
char m = msgs[headecho][0];
if(m >= 'A' && m <= 'A' + 15){
printf("applying %s\n", msgs[headecho]);
msgs[headecho][0] = 0;
}*/
time[tp] = rxtime + (double)i * 6.0 / 31250.0;
mstimer[tp] = p.ms;
for(int j=0; j<6; j++){
for(int k=0; k<4; k++){
char samp = p.data[j*4+k];
analog[tp*24+j*4+k] = samp;
channel[tp*24+j*4+k] = chans[k];
}
}
decodePacket(&p, channels, match);
for(int j=0; j<32; j++){
if(match[j]){
spike_ts[sp] = tp;
spike_ch[sp] = channel[j];
spike_unit[sp] = match[j];
sp++;
}
}
tp++;
}
}
pos += 16+siz;
} else if( u == 0xc0edfad0){
//ignore tx packets (for now?)
fread((void*)&u,4,1,in);
unsigned int siz = u & 0xffff;
//printf("u 0x%x\n",u);
txpackets += (siz)/32;
fseek(in,siz+8, SEEK_CUR);
pos += 16+siz;
} else if(u == 0xb00a5c11){
fread((void*)&u,4,1,in);
unsigned int siz = u & 0xffff;
//printf("u 0x%x\n",u);
double rxtime = 0.0;
fread((void*)&rxtime,8,1,in);
char buf[128];
fread((void*)buf,siz,1,in);
buf[siz] = 0;
//really need to wait for the echo here.
//bummish.
printf("message: %s\n", buf);
//first char: A-P (0-15, corresponds to echo); second space
char* b = buf; b+=2;
if(strncmp(b, "chan", 4) == 0){
int ii = b[5] - 'A';
if(ii >= 0 && ii < 4){
b += 7;
chans[ii] = atoi(b);
//printf(" chan %d changed to %d\n", ii, chans[ii]);
}
}
pos += 16+siz;
} else {
printf("magic number seems off, is 0x%x, %d bytes\n",
u,pos);
exit(0);
}
}
}
printf("finished reading in data file, now writing matlab file.\n");
matvar_t *matvar;
matvar = Mat_VarCreate("time",MAT_C_DOUBLE,MAT_T_DOUBLE,
1,&tp,time,0);
Mat_VarWrite( mat, matvar, 0 );
Mat_VarFree(matvar);
free(time); //I wish I had more.
matvar = Mat_VarCreate("mstimer",MAT_C_UINT32,MAT_T_UINT32,
1,&tp,mstimer,0);
Mat_VarWrite( mat, matvar, 0 );
Mat_VarFree(matvar);
free(mstimer);
int m = tp * 24;
matvar = Mat_VarCreate("analog",MAT_C_INT8,MAT_T_INT8,
1,&m,analog,0);
Mat_VarWrite( mat, matvar, 0 );
Mat_VarFree(matvar);
free(analog);
matvar = Mat_VarCreate("channel",MAT_C_INT8,MAT_T_INT8,
1,&m,channel,0);
Mat_VarWrite( mat, matvar, 0 );
Mat_VarFree(matvar);
free(channel);
matvar = Mat_VarCreate("spike_ts",MAT_C_UINT32,MAT_T_UINT32,
1,&sp,spike_ts,0);
Mat_VarWrite( mat, matvar, 0 );
Mat_VarFree(matvar);
free(spike_ts);
matvar = Mat_VarCreate("spike_ch",MAT_C_UINT32,MAT_T_UINT32,
1,&sp,spike_ch,0);
Mat_VarWrite( mat, matvar, 0 );
Mat_VarFree(matvar);
free(spike_ch);
matvar = Mat_VarCreate("spike_unit",MAT_C_UINT32,MAT_T_UINT32,
1,&sp,spike_unit,0);
Mat_VarWrite( mat, matvar, 0 );
Mat_VarFree(matvar);
free(spike_unit);
Mat_Close(mat);
fclose(in);
}
}
int main(int argc, char** argv)
{
DynareParams params(argc, argv);
if (params.help) {
params.printHelp();
return 0;
}
if (params.version) {
printf("Dynare++ v. %s. Copyright (C) 2004-2011, Ondra Kamenik\n",
DYNVERSION);
printf("Dynare++ comes with ABSOLUTELY NO WARRANTY and is distributed under\n");
printf("GPL: modules integ, tl, kord, sylv, src, extern and documentation\n");
printf("LGPL: modules parser, utils\n");
printf(" for GPL see http://www.gnu.org/licenses/gpl.html\n");
printf(" for LGPL see http://www.gnu.org/licenses/lgpl.html\n");
return 0;
}
THREAD_GROUP::max_parallel_threads = params.num_threads;
try {
// make journal name and journal
std::string jname(params.basename);
jname += ".jnl";
Journal journal(jname.c_str());
// make dynare object
Dynare dynare(params.modname, params.order, params.ss_tol, journal);
// make list of shocks for which we will do IRFs
vector<int> irf_list_ind;
if (params.do_irfs_all)
for (int i = 0; i < dynare.nexog(); i++)
irf_list_ind.push_back(i);
else
irf_list_ind = ((const DynareNameList&)dynare.getExogNames()).selectIndices(params.irf_list);
// write matlab files
FILE* mfd;
std::string mfile1(params.basename);
mfile1 += "_f.m";
if (NULL == (mfd=fopen(mfile1.c_str(), "w"))) {
fprintf(stderr, "Couldn't open %s for writing.\n", mfile1.c_str());
exit(1);
}
ogdyn::MatlabSSWriter writer0(dynare.getModel(), params.basename.c_str());
writer0.write_der0(mfd);
fclose(mfd);
std::string mfile2(params.basename);
mfile2 += "_ff.m";
if (NULL == (mfd=fopen(mfile2.c_str(), "w"))) {
fprintf(stderr, "Couldn't open %s for writing.\n", mfile2.c_str());
exit(1);
}
ogdyn::MatlabSSWriter writer1(dynare.getModel(), params.basename.c_str());
writer1.write_der1(mfd);
fclose(mfd);
// open mat file
std::string matfile(params.basename);
matfile += ".mat";
mat_t* matfd = Mat_Create(matfile.c_str(), NULL);
if (matfd == NULL) {
fprintf(stderr, "Couldn't open %s for writing.\n", matfile.c_str());
exit(1);
}
// write info about the model (dimensions and variables)
dynare.writeMat(matfd, params.prefix);
// write the dump file corresponding to the input
dynare.writeDump(params.basename);
system_random_generator.initSeed(params.seed);
tls.init(dynare.order(),
dynare.nstat()+2*dynare.npred()+3*dynare.nboth()+
2*dynare.nforw()+dynare.nexog());
Approximation app(dynare, journal, params.num_steps, params.do_centralize, params.qz_criterium);
try {
app.walkStochSteady();
} catch (const KordException& e) {
// tell about the exception and continue
printf("Caught (not yet fatal) Kord exception: ");
e.print();
JournalRecord rec(journal);
rec << "Solution routine not finished (" << e.get_message()
<< "), see what happens" << endrec;
}
std::string ss_matrix_name(params.prefix);
ss_matrix_name += "_steady_states";
ConstTwoDMatrix(app.getSS()).writeMat(matfd, ss_matrix_name.c_str());
// check the approximation
if (params.check_along_path || params.check_along_shocks
|| params.check_on_ellipse) {
GlobalChecker gcheck(app, THREAD_GROUP::max_parallel_threads, journal);
if (params.check_along_shocks)
gcheck.checkAlongShocksAndSave(matfd, params.prefix,
params.getCheckShockPoints(),
params.getCheckShockScale(),
params.check_evals);
if (params.check_on_ellipse)
gcheck.checkOnEllipseAndSave(matfd, params.prefix,
params.getCheckEllipsePoints(),
params.getCheckEllipseScale(),
params.check_evals);
if (params.check_along_path)
gcheck.checkAlongSimulationAndSave(matfd, params.prefix,
params.getCheckPathPoints(),
params.check_evals);
}
// write the folded decision rule to the Mat-4 file
app.getFoldDecisionRule().writeMat(matfd, params.prefix);
// simulate conditional
if (params.num_condper > 0 && params.num_condsim > 0) {
SimResultsDynamicStats rescond(dynare.numeq(), params.num_condper, 0);
ConstVector det_ss(app.getSS(),0);
rescond.simulate(params.num_condsim, app.getFoldDecisionRule(), det_ss, dynare.getVcov(), journal);
rescond.writeMat(matfd, params.prefix);
}
// simulate unconditional
//const DecisionRule& dr = app.getUnfoldDecisionRule();
const DecisionRule& dr = app.getFoldDecisionRule();
if (params.num_per > 0 && params.num_sim > 0) {
SimResultsStats res(dynare.numeq(), params.num_per, params.num_burn);
res.simulate(params.num_sim, dr, dynare.getSteady(), dynare.getVcov(), journal);
res.writeMat(matfd, params.prefix);
// impulse response functions
if (! irf_list_ind.empty()) {
IRFResults irf(dynare, dr, res, irf_list_ind, journal);
irf.writeMat(matfd, params.prefix);
}
}
// simulate with real-time statistics
if (params.num_rtper > 0 && params.num_rtsim > 0) {
RTSimResultsStats rtres(dynare.numeq(), params.num_rtper, params.num_burn);
rtres.simulate(params.num_rtsim, dr, dynare.getSteady(), dynare.getVcov(), journal);
rtres.writeMat(matfd, params.prefix);
}
Mat_Close(matfd);
} catch (const KordException& e) {
printf("Caugth Kord exception: ");
e.print();
return e.code();
} catch (const TLException& e) {
printf("Caugth TL exception: ");
e.print();
return 255;
} catch (SylvException& e) {
printf("Caught Sylv exception: ");
e.printMessage();
return 255;
} catch (const DynareException& e) {
printf("Caught Dynare exception: %s\n", e.message());
return 255;
} catch (const ogu::Exception& e) {
printf("Caught ogu::Exception: ");
e.print();
return 255;
} catch (const ogp::ParserException& e) {
printf("Caught parser exception: %s\n", e.message());
return 255;
}
return 0;
}
