trunk/pygtk/integratorreporter.cpp

#include "integrator.h"
#include "integratorreporter.h"

extern "C"{
#include <utilities/error.h>
#include <solver/integrator.h>
}

#include <vector>
#include <stdexcept>
#include <iostream>
#include <iterator>
#include <sstream>
using namespace std;

//---------------------------------------------
// NULL INTEGRATOR REPORTER (makes no output at all)

IntegratorReporterNull::IntegratorReporterNull(Integrator *integrator) : IntegratorReporterCxx(integrator){
    // nothing else
}

IntegratorReporterNull::~IntegratorReporterNull(){
    // nothing else
}

int
IntegratorReporterNull::initOutput(){
    return 1;
}

int IntegratorReporterNull::closeOutput(){
    return 1;
}

int IntegratorReporterNull::updateStatus(){
    return 1;
}

int IntegratorReporterNull::recordObservedValues(){
    return 1;
}

//------------------------------------------------------------------------------
// SIMPLE CONSOLE INTEGRATOR REPORTER

IntegratorReporterConsole::IntegratorReporterConsole(Integrator *integrator)
         : IntegratorReporterCxx(integrator), f(cout){
    // nothing else
}

IntegratorReporterConsole::~IntegratorReporterConsole(){
    // nothing else
}

int
IntegratorReporterConsole::initOutput(){
    long nobs = integrator->getNumObservedVars();
    stringstream ss;
    for(long i=0; i<nobs; ++i){
        if(i){
            f << "\t";
            ss << "\t";
        }
        Variable v = integrator->getObservedVariable(i);
        f << v.getName();
        ss << "-------";
    }
    f << endl;
    f << ss.str() << endl;
    return 1;
}

int IntegratorReporterConsole::closeOutput(){
    return 1;
}

int IntegratorReporterConsole::updateStatus(){
    return 1;
}

int IntegratorReporterConsole::recordObservedValues(){
    vector<double> data(integrator->getNumObservedVars());
    integrator_get_observations(integrator->getInternalType(),&data[0]);
    copy(data.begin(),data.end(),ostream_iterator<double>(f,"\t"));
    f << endl;
    return 1;
}

//----------------------------------------------------
// DEFAULT INTEGRATOR REPORTER (reporter start and end, outputs time at each step)

IntegratorReporterCxx::IntegratorReporterCxx(Integrator *integrator){
    // Initialise the C-API structure with flat function pointers
    reporter.init = &ascxx_integratorreporter_init;
    reporter.write = &ascxx_integratorreporter_write;
    reporter.write_obs = &ascxx_integratorreporter_write_obs;
    reporter.close = &ascxx_integratorreporter_close;
    this->integrator=integrator;
}

IntegratorReporterCxx::~IntegratorReporterCxx(){
    // nothing, just virtual destructor
    CONSOLE_DEBUG("DESTROYING INTEGRATOR REPORTER CXX");
}

IntegratorReporter *
IntegratorReporterCxx::getInternalType(){
    return &reporter;
}

int
IntegratorReporterCxx::initOutput(){
    return ERROR_REPORTER_NOLINE(ASC_USER_NOTE,"Starting integration reporting...");
}

int
IntegratorReporterCxx::closeOutput(){
    return ERROR_REPORTER_NOLINE(ASC_USER_NOTE,"Closing integration reporting...");
}

int
IntegratorReporterCxx::updateStatus(){
    double t = integrator->getCurrentTime();
    return ERROR_REPORTER_NOLINE(ASC_USER_NOTE,"t = %f",t);
}

int
IntegratorReporterCxx::recordObservedValues(){
    // CONSOLE_DEBUG("...");
    double *data = ASC_NEW_ARRAY(double,integrator->getNumObservedVars());
    integrator_get_observations(integrator->getInternalType(),data);
    return 0;
}

Integrator *
IntegratorReporterCxx::getIntegrator(){
    return integrator;
}

int ascxx_integratorreporter_init(IntegratorSystem *blsys){
    IntegratorReporterCxx *r = (IntegratorReporterCxx *)blsys->clientdata;
    if(r==NULL){
        throw runtime_error("blsys->clientdata was null");
    }
    return r->initOutput();
}

int ascxx_integratorreporter_write(IntegratorSystem *blsys){
    IntegratorReporterCxx *r = (IntegratorReporterCxx *)blsys->clientdata;
    return r->updateStatus();
}

int ascxx_integratorreporter_write_obs(IntegratorSystem *blsys){
    IntegratorReporterCxx *r = (IntegratorReporterCxx *)blsys->clientdata;
    return r->recordObservedValues();
}

int ascxx_integratorreporter_close(IntegratorSystem *blsys){
    IntegratorReporterCxx *r = (IntegratorReporterCxx *)blsys->clientdata;
    return r->closeOutput();
}
1	johnpye	669	#include "integrator.h"
2			#include "integratorreporter.h"
3
4			extern "C"{
5			#include <utilities/error.h>
6			#include <solver/integrator.h>
7			}
8
9	johnpye	944	#include <vector>
10	johnpye	669	#include <stdexcept>
11	johnpye	944	#include <iostream>
12			#include <iterator>
13			#include <sstream>
14	johnpye	669	using namespace std;
15
16	johnpye	940	//---------------------------------------------
17			// NULL INTEGRATOR REPORTER (makes no output at all)
18
19			IntegratorReporterNull::IntegratorReporterNull(Integrator *integrator) : IntegratorReporterCxx(integrator){
20			// nothing else
21			}
22
23			IntegratorReporterNull::~IntegratorReporterNull(){
24			// nothing else
25			}
26
27			int
28			IntegratorReporterNull::initOutput(){
29			return 1;
30			}
31
32			int IntegratorReporterNull::closeOutput(){
33			return 1;
34			}
35
36			int IntegratorReporterNull::updateStatus(){
37			return 1;
38			}
39
40			int IntegratorReporterNull::recordObservedValues(){
41			return 1;
42			}
43
44	johnpye	944	//------------------------------------------------------------------------------
45			// SIMPLE CONSOLE INTEGRATOR REPORTER
46	johnpye	940
47	johnpye	944	IntegratorReporterConsole::IntegratorReporterConsole(Integrator *integrator)
48			: IntegratorReporterCxx(integrator), f(cout){
49			// nothing else
50			}
51
52			IntegratorReporterConsole::~IntegratorReporterConsole(){
53			// nothing else
54			}
55
56			int
57			IntegratorReporterConsole::initOutput(){
58			long nobs = integrator->getNumObservedVars();
59			stringstream ss;
60			for(long i=0; i<nobs; ++i){
61			if(i){
62			f << "\t";
63			ss << "\t";
64			}
65			Variable v = integrator->getObservedVariable(i);
66			f << v.getName();
67			ss << "-------";
68			}
69			f << endl;
70			f << ss.str() << endl;
71			return 1;
72			}
73
74			int IntegratorReporterConsole::closeOutput(){
75			return 1;
76			}
77
78			int IntegratorReporterConsole::updateStatus(){
79			return 1;
80			}
81
82			int IntegratorReporterConsole::recordObservedValues(){
83			vector<double> data(integrator->getNumObservedVars());
84			integrator_get_observations(integrator->getInternalType(),&data[0]);
85			copy(data.begin(),data.end(),ostream_iterator<double>(f,"\t"));
86			f << endl;
87			return 1;
88			}
89
90	johnpye	940	//----------------------------------------------------
91			// DEFAULT INTEGRATOR REPORTER (reporter start and end, outputs time at each step)
92
93	johnpye	669	IntegratorReporterCxx::IntegratorReporterCxx(Integrator *integrator){
94			// Initialise the C-API structure with flat function pointers
95			reporter.init = &ascxx_integratorreporter_init;
96			reporter.write = &ascxx_integratorreporter_write;
97			reporter.write_obs = &ascxx_integratorreporter_write_obs;
98			reporter.close = &ascxx_integratorreporter_close;
99			this->integrator=integrator;
100			}
101
102			IntegratorReporterCxx::~IntegratorReporterCxx(){
103			// nothing, just virtual destructor
104			CONSOLE_DEBUG("DESTROYING INTEGRATOR REPORTER CXX");
105			}
106
107			IntegratorReporter *
108			IntegratorReporterCxx::getInternalType(){
109			return &reporter;
110			}
111
112			int
113			IntegratorReporterCxx::initOutput(){
114	johnpye	711	return ERROR_REPORTER_NOLINE(ASC_USER_NOTE,"Starting integration reporting...");
115	johnpye	669	}
116
117			int
118			IntegratorReporterCxx::closeOutput(){
119	johnpye	711	return ERROR_REPORTER_NOLINE(ASC_USER_NOTE,"Closing integration reporting...");
120	johnpye	669	}
121
122			int
123			IntegratorReporterCxx::updateStatus(){
124			double t = integrator->getCurrentTime();
125	johnpye	711	return ERROR_REPORTER_NOLINE(ASC_USER_NOTE,"t = %f",t);
126	johnpye	669	}
127
128			int
129			IntegratorReporterCxx::recordObservedValues(){
130	johnpye	888	// CONSOLE_DEBUG("...");
131	johnpye	669	double *data = ASC_NEW_ARRAY(double,integrator->getNumObservedVars());
132			integrator_get_observations(integrator->getInternalType(),data);
133	johnpye	711	return 0;
134	johnpye	669	}
135
136			Integrator *
137			IntegratorReporterCxx::getIntegrator(){
138			return integrator;
139			}
140
141			int ascxx_integratorreporter_init(IntegratorSystem *blsys){
142			IntegratorReporterCxx r = (IntegratorReporterCxx )blsys->clientdata;
143			if(r==NULL){
144			throw runtime_error("blsys->clientdata was null");
145			}
146			return r->initOutput();
147			}
148
149			int ascxx_integratorreporter_write(IntegratorSystem *blsys){
150			IntegratorReporterCxx r = (IntegratorReporterCxx )blsys->clientdata;
151			return r->updateStatus();
152			}
153
154			int ascxx_integratorreporter_write_obs(IntegratorSystem *blsys){
155			IntegratorReporterCxx r = (IntegratorReporterCxx )blsys->clientdata;
156			return r->recordObservedValues();
157			}
158
159			int ascxx_integratorreporter_close(IntegratorSystem *blsys){
160			IntegratorReporterCxx r = (IntegratorReporterCxx )blsys->clientdata;
161			return r->closeOutput();
162			}