std::pair<std::vector<float>, std::vector<int> > make_fake_dataset(std::vector<Signal>& signals,
std::vector<Systematic>& systematics,
std::vector<Observable>& observables,
std::vector<double> params, bool poisson, int maxsamples) {
std::cout << "make_fake_dataset: Generating dataset..." << std::endl;
std::vector<double> syst_vals;
for (size_t i=signals.size();i<signals.size()+systematics.size();i++){
syst_vals.push_back(params[i]);
}
std::vector<float> upper;
std::vector<float> lower;
for (size_t i=0;i<observables.size();i++){
upper.push_back(observables[i].upper);
lower.push_back(observables[i].lower);
}
std::vector<float> events;
std::vector<int> weights;
std::vector<unsigned> observed(signals.size());
for (size_t i=0;i<signals.size();i++){
observed[i] = \
dynamic_cast<pdfz::EvalHist*>(signals[i].histogram)->RandomSample(events,weights,params[i],
syst_vals,upper,lower,poisson,maxsamples);
std::cout << "make_fake_dataset: " << signals[i].name << ": "
<< observed[i] << " events (" << signals[i].nexpected
<< " expected)" << std::endl;
}
return std::make_pair(events,weights);
}
Type objective_function<Type>::operator() ()
{
DATA_VECTOR(observed);
PARAMETER_VECTOR(population);
PARAMETER(log_process_error);
PARAMETER(log_obs_error);
Type process_error = exp(log_process_error);
Type obs_error = exp(log_obs_error);
int n_obs = observed.size(); // number of observations
Type nll = 0; // negative log likelihood
// likelihood for state transitions
for(int y=1; y<n_obs; y++){
Type m = population[y-1];
nll -= dnorm(population(y), m, process_error, true);
}
// likelihood for observations
for(int y=0; y<n_obs; y++){
nll -= dnorm(observed(y), population(y), obs_error, true);
}
ADREPORT(process_error);
ADREPORT(obs_error);
return nll;
}
void HostedObject::handleLocationUpdate(const SpaceObjectReference& observer, const LocUpdate& lu) {
ProxyManagerPtr proxy_manager = this->getProxyManager(observer.space(), observer.object());
if (!proxy_manager) {
HO_LOG(warn,"Hosted Object received a message for a presence without a proxy manager.");
return;
}
SpaceObjectReference observed(observer.space(), ObjectReference(lu.object()));
ProxyObjectPtr proxy_obj = proxy_manager->getProxyObject(observed);
assert(proxy_obj);
this->processLocationUpdate( observer, proxy_obj, lu);
}
TEST(TermTableBuilder, GeneralCases)
{
// Construct a test environment that provides the ITermTreatment
// and DocumentFrequencyTable to be used by the TermTableBuilder.
// The test environment also provides a hand-constructed expected
// TermTable for verification purposes.
TestEnvironment environment;
// Run the TermTableBuilder to configure a TermTable.
ITermTreatment const & treatment = environment.GetTermTreatment();
DocumentFrequencyTable const & terms =
environment.GetDocFrequencyTable();
IFactSet const & facts = environment.GetFactSet();
TermTable termTable;
double density = 0.1;
double adhocFrequency = 0.0001;
unsigned c_randomSkipDistance = 0;
TermTableBuilder builder(density,
adhocFrequency,
treatment,
terms,
facts,
termTable,
c_randomSkipDistance);
// builder.Print(std::cout);
//
// Verify that configured TermTable is the same as the expected
// TermTable provided by the environment.
//
// Ensure that all known terms have the same RowIdSequences.
// NOTE: This test relies on the existence of a separate unit test
// for TermTable that ensures that RowIds and Terms are added
// correctly. Without such a test, a bogus TermTable that ignores
// all RowId additions would allow TermTableBuilderTest to pass
// (because they will both return the empty set of rows).
for (auto term : terms)
{
RowIdSequence expected(term.GetTerm(),
environment.GetTermTable());
RowIdSequence observed(term.GetTerm(), termTable);
EXPECT_TRUE(std::equal(observed.begin(),
observed.end(),
expected.begin()));
EXPECT_TRUE(std::equal(expected.begin(),
expected.end(),
observed.begin()));
}
// NOTE: This test relies on the existence of a separate unit test
// for TermTable that ensures that row counts are recorded
// correctly. Without such a test, a bogus TermTable that ignores
// all SetRowCounts would allow TermTableBuilderTest to pass.
for (Rank rank = 0; rank <= c_maxRankValue; ++rank)
{
EXPECT_EQ(environment.GetTermTable().GetTotalRowCount(rank),
termTable.GetTotalRowCount(rank));
}
// TODO: Verify adhoc
// TODO: Verify facts
// TODO: Verify row counts.
}
/*!
* @if jp
* @brief RTObjectへのリスナ接続処理
* @else
* @brief Connectiong listeners to RTObject
* @endif
*/
void ComponentObserverConsumer::setListeners(coil::Properties& prop)
{
if (prop["observed_status"].empty())
{
prop["observed_status"] = "ALL";
}
coil::vstring observed(coil::split(prop["observed_status"], ","));
bool flags[OpenRTM::STATUS_KIND_NUM];
for (int i(0); i < OpenRTM::STATUS_KIND_NUM; ++i)
{
flags[i] = false;
}
for (size_t i(0); i < observed.size(); ++i)
{
coil::toUpper(observed[i]);
if (observed[i] == "COMPONENT_PROFILE")
{
flags[OpenRTM::COMPONENT_PROFILE] = 1;
}
else if (observed[i] == "RTC_STATUS")
{
flags[OpenRTM::RTC_STATUS] = 1;
}
else if (observed[i] == "EC_STATUS")
{
flags[OpenRTM::EC_STATUS] = 1;
}
else if (observed[i] == "PORT_PROFILE")
{
flags[OpenRTM::PORT_PROFILE] = 1;
}
else if (observed[i] == "CONFIGURATION")
{
flags[OpenRTM::CONFIGURATION] = 1;
}
else if (observed[i] == "ALL")
{
for (int j(0); j < OpenRTM::STATUS_KIND_NUM; ++j)
{
flags[j] = true;
}
break;
}
}
switchListeners(flags[OpenRTM::COMPONENT_PROFILE],
m_observed[OpenRTM::COMPONENT_PROFILE],
&ComponentObserverConsumer::setComponentProfileListeners,
&ComponentObserverConsumer::unsetComponentProfileListeners);
switchListeners(flags[OpenRTM::RTC_STATUS],
m_observed[OpenRTM::RTC_STATUS],
&ComponentObserverConsumer::setComponentStatusListeners,
&ComponentObserverConsumer::unsetComponentStatusListeners);
switchListeners(flags[OpenRTM::EC_STATUS],
m_observed[OpenRTM::EC_STATUS],
&ComponentObserverConsumer::setExecutionContextListeners,
&ComponentObserverConsumer::unsetExecutionContextListeners);
switchListeners(flags[OpenRTM::PORT_PROFILE],
m_observed[OpenRTM::PORT_PROFILE],
&ComponentObserverConsumer::setPortProfileListeners,
&ComponentObserverConsumer::unsetPortProfileListeners);
switchListeners(flags[OpenRTM::CONFIGURATION],
m_observed[OpenRTM::CONFIGURATION],
&ComponentObserverConsumer::setConfigurationListeners,
&ComponentObserverConsumer::unsetConfigurationListeners);
}
