Sensix Wireless Sensor Network Middleware    Home    Project Page    Download    CVS  Hosted by

/home/brennan/Software/sensix/source/L3/sensing.cpp Go to the documentation of this file. /* * Copyright 2008. Los Alamos National Security, LLC. This material * was produced under U.S. Government contract DE-AC52-06NA25396 for * Los Alamos National Laboratory (LANL), which is operated by Los * Alamos National Security, LLC, for the Department of Energy. The * U.S. Government has rights to use, reproduce, and distribute this * software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY, * LLC, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL * LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to * produce derivative works, such modified software should be clearly * marked, so as not to confuse it with the version available from LANL. * * Additionally, this program is free software; you can redistribute * it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; version 2 of * the License. Accordingly, this program is distributed in the hope * it will be useful, but WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #include <stdlib.h> #include <float.h> #include <math.h> #include <sys/time.h> #include <time.h> #include <pthread.h> #include "sensing.h" #include "sensix.h" #include "sense_impl.h" using namespace sensix; using namespace sensix::sensing; static pthread_mutex_t seq_mutex = PTHREAD_MUTEX_INITIALIZER; static unsigned int SEQUENCE = 0; #define MAX_SEQ 16777215 FunctorImpl::FunctorImpl(FunctorList *subfs) : Functor() { id = INVALID; subs = subfs; data_set = new Series(); errs = new ErrorList(); pthread_mutex_lock(&seq_mutex); seq_num = SEQUENCE; SEQUENCE++; if (SEQUENCE == MAX_SEQ) SEQUENCE = 0; pthread_mutex_unlock(&seq_mutex); } FunctorImpl::FunctorImpl() : Functor() { id = INVALID; subs = new FunctorList(); data_set = new Series(); errs = new ErrorList(); pthread_mutex_lock(&seq_mutex); seq_num = SEQUENCE; SEQUENCE++; if (SEQUENCE == MAX_SEQ) SEQUENCE = 0; pthread_mutex_unlock(&seq_mutex); } FunctorImpl::FunctorImpl(FunctorList *subfs, unsigned int seq) : Functor() { id = INVALID; subs = subfs; data_set = new Series(); errs = new ErrorList(); seq_num = seq; } FunctorImpl::FunctorImpl(unsigned int seq) : Functor() { id = INVALID; subs = new FunctorList(); data_set = new Series(); errs = new ErrorList(); seq_num = seq; } uint8_t FunctorImpl::identifier() { return id; } unsigned int FunctorImpl::sequencer() { return seq_num; } Series* FunctorImpl::results() { return data_set; } void FunctorImpl::results(Series &data) { Series *tmp = data_set; data_set = &data; delete tmp; } ErrorList* FunctorImpl::errors() { return errs; } void FunctorImpl::errors(ErrorList &e) { ErrorList *tmp = errs; errs = &e; delete tmp; } uint8_t FunctorImpl::priority() { return importance; } void FunctorImpl::priority(uint8_t p) { importance = p; } FunctorList* FunctorImpl::subfunctors() { return subs; } void FunctorImpl::subfunctors(FunctorList &fs) { FunctorList *tmp = subs; subs = &fs; delete tmp; } char *FunctorImpl::asString() { return CORBA::string_dup("functor(invalid)"); } SensoryImpl::SensoryImpl(uint8_t l, uint8_t s, FunctorList *subfs) : Sensory() { delegate = new FunctorImpl(subfs); h_level = l; sense = s; } SensoryImpl::SensoryImpl(uint8_t l, uint8_t s) : Sensory() { delegate = new FunctorImpl(); h_level = l; sense = s; } SensoryImpl::SensoryImpl(FunctorList *subfs) : Sensory() { delegate = new FunctorImpl(subfs); h_level = INVALID; sense = INVALID; } SensoryImpl::SensoryImpl() : Sensory() { delegate = new FunctorImpl(); h_level = INVALID; sense = INVALID; } SensoryImpl::SensoryImpl(uint8_t l, uint8_t s, FunctorList *subfs, unsigned int seq) : Sensory() { delegate = new FunctorImpl(subfs, seq); h_level = l; sense = s; } SensoryImpl::SensoryImpl(uint8_t l, uint8_t s, unsigned int seq) : Sensory() { delegate = new FunctorImpl(seq); h_level = l; sense = s; } uint8_t SensoryImpl::level() { return h_level; } uint8_t SensoryImpl::sensor() { return sense; } unsigned long long SensoryImpl::timeused() { return time; } void SensoryImpl::timeused(unsigned long long t) { time = t; } double SensoryImpl::energyused() { return energy; } void SensoryImpl::energyused(double e) { energy = e; } char *SensoryImpl::asString() { return delegate->asString(); } uint8_t SensoryImpl::identifier() { return delegate->identifier(); } unsigned int SensoryImpl::sequencer() { return delegate->sequencer(); } Series *SensoryImpl::results() { return delegate->results(); } void SensoryImpl::results(Series &data) { delegate->results(data); } ErrorList *SensoryImpl::errors() { return delegate->errors(); } void SensoryImpl::errors(ErrorList &e) { delegate->errors(e); } uint8_t SensoryImpl::priority() { return delegate->priority(); } void SensoryImpl::priority(uint8_t p) { delegate->priority(); } FunctorList *SensoryImpl::subfunctors() { return delegate->subfunctors(); } void SensoryImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } CollectionImpl::CollectionImpl(uint8_t l, Sensory_ptr s) : Collection() { FunctorList *array = new FunctorList(); array->length(1); (*array)[0] = s; delegate = new SensoryImpl(l, s->sensor(), array); sensory = s; data = new Series(); } CollectionImpl::CollectionImpl(Sensory_ptr s) : Collection() { FunctorList *array = new FunctorList(); array->length(1); (*array)[0] = s; delegate = new SensoryImpl(array); sensory = s; data = new Series(); } CollectionImpl::CollectionImpl(uint8_t l, Sensory_ptr s, unsigned int seq) : Collection() { FunctorList *array = new FunctorList(); array->length(1); (*array)[0] = s; delegate = new SensoryImpl(l, s->sensor(), array, seq); sensory = s; data = new Series(); } Sensory_ptr CollectionImpl::sense() { return sensory; } void CollectionImpl::sense(Sensory_ptr s) { if (s != NULL) sensory = s; } uint8_t CollectionImpl::sensor() { return sensory->sensor(); } unsigned long long CollectionImpl::timeused() { return sensory->timeused(); } double CollectionImpl::energyused() { return sensory->energyused(); } uint8_t CollectionImpl::priority() { return sensory->priority(); } void CollectionImpl::priority(uint8_t p) { sensory->priority(p); } Series* CollectionImpl::results() { return data; } void CollectionImpl::results(Series &d) { unsigned int pos = data->length(); data->length(pos + d.length()); for (unsigned int i = 0; i < d.length(); i++) (*data)[pos + i] = d[i]; } ErrorList* CollectionImpl::errors() { return sensory->errors(); } char *CollectionImpl::asString() { return delegate->asString(); } uint8_t CollectionImpl::identifier() { return delegate->identifier(); } unsigned int CollectionImpl::sequencer() { return delegate->sequencer(); } uint8_t CollectionImpl::level() { return delegate->level(); } FunctorList *CollectionImpl::subfunctors() { return delegate->subfunctors(); } void CollectionImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } AggregateImpl::AggregateImpl(char *n, uint8_t l, CollectionList *c) : Aggregate() { delegate = new SensoryImpl(l, INVALID, (FunctorList*)c); name = n; series = c; } AggregateImpl::AggregateImpl(char *n, CollectionList *c) : Aggregate() { delegate = new SensoryImpl((FunctorList*)c); name = n; series = c; } AggregateImpl::AggregateImpl(char *n, uint8_t l, CollectionList *c, unsigned int seq) : Aggregate() { delegate = new SensoryImpl(l, INVALID, (FunctorList*)c, seq); name = n; series = c; } SensoryList* AggregateImpl::senses() { unsigned int num = series->length(); SensoryList *array = new SensoryList(); array->length(num); for (unsigned int i = 0; i < num; i++) { Collection *c = (*series)[i]; Sensory_ptr s = c->sense(); (*array)[i] = s; } return array; } CollectionList* AggregateImpl::collectors() { return series; } void AggregateImpl::collectors(CollectionList *c) { series = c; } Sensory_ptr AggregateImpl::sense() // TODO: this is meaningless, should go away { Collection *c = (*series)[0]; return c->sense(); } uint8_t AggregateImpl::sensor() { return INVALID; } unsigned long long AggregateImpl::timeused() { unsigned long long max = 0; for (unsigned int i = 0; i < series->length(); i++) { Collection *c = (*series)[i]; if (c->timeused() > max) max = c->timeused(); } return max; } double AggregateImpl::energyused() { double sum = 0.0; for (unsigned int i = 0; i < series->length(); i++) { Collection *c = (*series)[i]; sum += c->energyused(); } return sum; } uint8_t AggregateImpl::priority() { uint8_t max = 0; for (unsigned int i = 0; i < series->length(); i++) { Collection *c = (*series)[i]; if (c->priority() > max) max = c->priority(); } return max; } void AggregateImpl::priority(uint8_t p) { for (unsigned int i = 0; i < series->length(); i++) { Collection *c = (*series)[i]; c->priority(p); } } ErrorList* AggregateImpl::errors() { unsigned int num = 0, pos = 0; for (unsigned int i = 0; i < series->length(); i++) { Collection *c = (*series)[i]; if (c->errors() != NULL) num += c->errors()->length(); } ErrorList *e = new ErrorList(); e->length(num); for (unsigned int i = 0; i < series->length(); i++) { Collection *c = (*series)[i]; if (c->errors() != NULL && c->errors()->length() > 0) { for (unsigned int j = 0; j < c->errors()->length(); j++) { ErrorList *el = c->errors(); (*e)[pos] = (*el)[j]; pos++; } } } return e; } char *AggregateImpl::asString() { char str[2048], lvl[64]; memset(lvl, 0, 64); memset(str, 0, 512); sprintf(str, "%s(", name); if (delegate->level() != INVALID) { sprintf(lvl, "level=%u,", delegate->level()); strcat(str, lvl); } for (unsigned int i = 0; i < series->length(); i ++) { Collection *c = (*series)[i]; char *s_str = c->asString(); strcat(str, s_str); CORBA::string_free(s_str); if (i < series->length() - 1) strcat(str, "&&"); } strcat(str, ")"); return CORBA::string_dup(str); } uint8_t AggregateImpl::identifier() { return delegate->identifier(); } unsigned int AggregateImpl::sequencer() { return delegate->sequencer(); } uint8_t AggregateImpl::level() { return delegate->level(); } Series* AggregateImpl::results() { return delegate->results(); } void AggregateImpl::results(Series &d) { delegate->results(d); } FunctorList *AggregateImpl::subfunctors() { return delegate->subfunctors(); } void AggregateImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } SenseImpl::SenseImpl(uint8_t l, uint8_t s, double r) : Sense() { delegate = new SensoryImpl(l, s); hz = r; } SenseImpl::SenseImpl(uint8_t s, double r) : Sense() { delegate = new SensoryImpl(INVALID, s); hz = r; } SenseImpl::SenseImpl(uint8_t l, uint8_t s) : Sense() { delegate = new SensoryImpl(l, s); hz = 0.0; } SenseImpl::SenseImpl(uint8_t s) : Sense() { delegate = new SensoryImpl(INVALID, s); hz = 0.0; } SenseImpl::SenseImpl(uint8_t l, uint8_t s, double r, unsigned int seq) : Sense() { delegate = new SensoryImpl(l, s, seq); hz = r; } double SenseImpl::rate() { return hz; } void SenseImpl::rate(double r) { hz = r; } uint8_t SenseImpl::identifier() { return ALPHA; } char *SenseImpl::asString() { char str[2048], lvl[64], snsr[64], rt[64]; memset(rt, 0, 64); memset(snsr, 0, 64); memset(lvl, 0, 64); memset(str, 0, 512); sprintf(str, "Sense("); if (delegate->level() != INVALID) { sprintf(lvl, "level=%u,", delegate->level()); strcat(str, lvl); } strcat(str, "sensor="); capabilityToString(snsr, delegate->sensor()); strcat(str, snsr); if (hz > 0.0) { sprintf(rt, ",rate=%lf", hz); strcat(str, rt); } strcat(str, ")"); return CORBA::string_dup(str); } unsigned int SenseImpl::sequencer() { return delegate->sequencer(); } uint8_t SenseImpl::level() { return delegate->level(); } unsigned long long SenseImpl::timeused() { return delegate->timeused(); } void SenseImpl::timeused(unsigned long long t) { delegate->timeused(t); } double SenseImpl::energyused() { return delegate->energyused(); } void SenseImpl::energyused(double e) { delegate->energyused(e); } Series* SenseImpl::results() { return delegate->results(); } void SenseImpl::results(Series &d) { delegate->results(d); } uint8_t SenseImpl::priority() { return delegate->priority(); } void SenseImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* SenseImpl::errors() { return delegate->errors(); } void SenseImpl::errors(ErrorList &e) { delegate->errors(e); } PeakSenseImpl::PeakSenseImpl(uint8_t l, uint8_t s, double r, double th, bool hi) : PeakSense() { delegate = new SenseImpl(l, s, r); if (hi) { threshold_h = th; threshold_l = -(DBL_MAX); } else { threshold_h = DBL_MAX; threshold_l = th; } } PeakSenseImpl::PeakSenseImpl(uint8_t l, uint8_t s, double r, double th, double tl) : PeakSense() { delegate = new SenseImpl(l, s, r); threshold_h = th; threshold_l = tl; } PeakSenseImpl::PeakSenseImpl(uint8_t s, double r, double th, bool hi) : PeakSense() { delegate = new SenseImpl(s, r); if (hi) { threshold_h = th; threshold_l = -(DBL_MAX); } else { threshold_h = DBL_MAX; threshold_l = th; } } PeakSenseImpl::PeakSenseImpl(uint8_t s, double r, double th, double tl) : PeakSense() { delegate = new SenseImpl(s, r); threshold_h = th; threshold_l = tl; } PeakSenseImpl::PeakSenseImpl(uint8_t l, uint8_t s, double th, bool hi) : PeakSense() { delegate = new SenseImpl(l, s); if (hi) { threshold_h = th; threshold_l = -(DBL_MAX); } else { threshold_h = DBL_MAX; threshold_l = th; } } PeakSenseImpl::PeakSenseImpl(uint8_t l, uint8_t s, double th, double tl) : PeakSense() { delegate = new SenseImpl(l, s); threshold_h = th; threshold_l = tl; } PeakSenseImpl::PeakSenseImpl(uint8_t s, double th, bool hi) : PeakSense() { delegate = new SenseImpl(s); if (hi) { threshold_h = th; threshold_l = -(DBL_MAX); } else { threshold_h = DBL_MAX; threshold_l = th; } } PeakSenseImpl::PeakSenseImpl(uint8_t s, double th, double tl) : PeakSense() { delegate = new SenseImpl(s); threshold_h = th; threshold_l = tl; } PeakSenseImpl::PeakSenseImpl(uint8_t l, uint8_t s, double r, double th, double tl, unsigned int seq) : PeakSense() { delegate = new SenseImpl(l, s, r, seq); threshold_h = th; threshold_l = tl; } double PeakSenseImpl::highthreshold() { return threshold_h; } void PeakSenseImpl::highthreshold(double h) { threshold_h = h; } double PeakSenseImpl::lowthreshold() { return threshold_l; } void PeakSenseImpl::lowthreshold(double l) { threshold_l = l; } uint8_t PeakSenseImpl::identifier() { return BETA; } char *PeakSenseImpl::asString() { char str[2048], lvl[64], snsr[64], rt[64], hth[64], lth[64]; memset(lth, 0, 64); memset(hth, 0, 64); memset(rt, 0, 64); memset(snsr, 0, 64); memset(lvl, 0, 64); memset(str, 0, 512); sprintf(str, "PeakSense("); if (delegate->level() != INVALID) { sprintf(lvl, "level=%u,", delegate->level()); strcat(str, lvl); } strcat(str, "sensor="); capabilityToString(snsr, delegate->sensor()); strcat(str, snsr); if (delegate->rate() > 0.0) { sprintf(rt, ",rate=%lf", delegate->rate()); strcat(str, rt); } if (threshold_h != DBL_MAX) { sprintf(hth, ",high threshold=%lf", threshold_h); strcat(str, hth); } if (threshold_l != -(DBL_MAX)) { sprintf(lth, ",low threshold=%lf", threshold_l); strcat(str, lth); } strcat(str, ")"); return CORBA::string_dup(str); } double PeakSenseImpl::rate() { return delegate->rate(); } void PeakSenseImpl::rate(double r) { delegate->rate(r); } unsigned int PeakSenseImpl::sequencer() { return delegate->sequencer(); } uint8_t PeakSenseImpl::level() { return delegate->level(); } unsigned long long PeakSenseImpl::timeused() { return delegate->timeused(); } void PeakSenseImpl::timeused(unsigned long long t) { delegate->timeused(t); } double PeakSenseImpl::energyused() { return delegate->energyused(); } void PeakSenseImpl::energyused(double e) { delegate->energyused(e); } Series* PeakSenseImpl::results() { return delegate->results(); } void PeakSenseImpl::results(Series &data) { Data *d = &(data[0]); double val = 0.0; if (isIntegerData(d->_d())) val = d->iresult(); else if (isFloatingPointData(d->_d())) val = d->fresult(); if (val > threshold_l && val < threshold_h) delegate->results(data); } uint8_t PeakSenseImpl::priority() { return delegate->priority(); } void PeakSenseImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* PeakSenseImpl::errors() { return delegate->errors(); } void PeakSenseImpl::errors(ErrorList &e) { delegate->errors(e); } FunctorList *PeakSenseImpl::subfunctors() { return delegate->subfunctors(); } void PeakSenseImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } TimeSeriesImpl::TimeSeriesImpl(uint8_t l, Sensory_ptr s, unsigned long long t) : TimeSeries() { delegate = new CollectionImpl(l, s); time = t; } TimeSeriesImpl::TimeSeriesImpl(Sensory_ptr s, unsigned long long t) : TimeSeries() { delegate = new CollectionImpl(s); time = t; } TimeSeriesImpl::TimeSeriesImpl(uint8_t l, Sensory_ptr s, unsigned long long t, unsigned int seq) : TimeSeries() { delegate = new CollectionImpl(l, s, seq); time = t; } unsigned long long TimeSeriesImpl::duration() { return time; } void TimeSeriesImpl::duration(unsigned long long t) { time = t; } uint8_t TimeSeriesImpl::identifier() { return THETA; } char *TimeSeriesImpl::asString() { char str[2048], lvl[64], dur[64], *sub; memset(dur, 0, 64); memset(lvl, 0, 64); memset(str, 0, 512); sprintf(str, "TimeSeries("); if (delegate->level() != INVALID) { sprintf(lvl, "level=%u,", delegate->level()); strcat(str, lvl); } sprintf(dur, "duration=%Lu,", time); strcat(str, dur); sub = delegate->sense()->asString(); strcat(str, sub); CORBA::string_free(sub); strcat(str, ")"); return CORBA::string_dup(str); } unsigned int TimeSeriesImpl::sequencer() { return delegate->sequencer(); } uint8_t TimeSeriesImpl::level() { return delegate->level(); } Sensory_ptr TimeSeriesImpl::sense() { return delegate->sense(); } void TimeSeriesImpl::sense(Sensory_ptr s) { delegate->sense(s); } uint8_t TimeSeriesImpl::sensor() { return delegate->sensor(); } unsigned long long TimeSeriesImpl::timeused() { return delegate->timeused(); } void TimeSeriesImpl::timeused(unsigned long long t) { delegate->timeused(t); } double TimeSeriesImpl::energyused() { return delegate->energyused(); } void TimeSeriesImpl::energyused(double e) { delegate->energyused(e); } Series* TimeSeriesImpl::results() { return delegate->results(); } void TimeSeriesImpl::results(Series &data) { delegate->results(data); } uint8_t TimeSeriesImpl::priority() { return delegate->priority(); } void TimeSeriesImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* TimeSeriesImpl::errors() { return delegate->errors(); } void TimeSeriesImpl::errors(ErrorList &e) { delegate->errors(e); } FunctorList *TimeSeriesImpl::subfunctors() { return delegate->subfunctors(); } void TimeSeriesImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } SpatialSeriesImpl::SpatialSeriesImpl(uint8_t l, Sensory_ptr s, double angle, double dist) : SpatialSeries() { delegate = new CollectionImpl(l, s); centirads = angle; dist_cm = dist; } SpatialSeriesImpl::SpatialSeriesImpl(Sensory_ptr s, double angle, double dist) : SpatialSeries() { delegate = new CollectionImpl(s); centirads = angle; dist_cm = dist; } SpatialSeriesImpl::SpatialSeriesImpl(uint8_t l, Sensory_ptr s) : SpatialSeries() { delegate = new CollectionImpl(l, s); centirads = -1.0; dist_cm = -1.0; } SpatialSeriesImpl::SpatialSeriesImpl(Sensory_ptr s) : SpatialSeries() { delegate = new CollectionImpl(s); centirads = -1.0; dist_cm = -1.0; } SpatialSeriesImpl::SpatialSeriesImpl(uint8_t l, Sensory_ptr s, double angle, double dist, unsigned int seq) : SpatialSeries() { delegate = new CollectionImpl(l, s, seq); centirads = angle; dist_cm = dist; } double SpatialSeriesImpl::distance() { return dist_cm; } void SpatialSeriesImpl::distance(double d) { dist_cm = d; } double SpatialSeriesImpl::angle() { return centirads; } void SpatialSeriesImpl::angle(double a) { centirads = a; } uint8_t SpatialSeriesImpl::identifier() { return PSI; } char *SpatialSeriesImpl::asString() { char str[2048], lvl[64], a[64], d[64], *sub; memset(d, 0, 64); memset(a, 0, 64); memset(lvl, 0, 64); memset(str, 0, 512); sprintf(str, "SpatialSeries("); if (delegate->level() != INVALID) { sprintf(lvl, "level=%u,", delegate->level()); strcat(str, lvl); } if (centirads > 0.0) { sprintf(a, "angle=%lf,", centirads); strcat(str, a); } if (dist_cm > 0.0) { sprintf(d, "distance=%lf,", dist_cm); strcat(str, d); } sub = delegate->sense()->asString(); strcat(str, sub); CORBA::string_free(sub); strcat(str, ")"); return CORBA::string_dup(str); } unsigned int SpatialSeriesImpl::sequencer() { return delegate->sequencer(); } uint8_t SpatialSeriesImpl::level() { return delegate->level(); } Sensory_ptr SpatialSeriesImpl::sense() { return delegate->sense(); } void SpatialSeriesImpl::sense(Sensory_ptr s) { delegate->sense(s); } uint8_t SpatialSeriesImpl::sensor() { return delegate->sensor(); } unsigned long long SpatialSeriesImpl::timeused() { return delegate->timeused(); } void SpatialSeriesImpl::timeused(unsigned long long t) { delegate->timeused(t); } double SpatialSeriesImpl::energyused() { return delegate->energyused(); } void SpatialSeriesImpl::energyused(double e) { delegate->energyused(e); } Series* SpatialSeriesImpl::results() { return delegate->results(); } void SpatialSeriesImpl::results(Series &data) { delegate->results(data); } uint8_t SpatialSeriesImpl::priority() { return delegate->priority(); } void SpatialSeriesImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* SpatialSeriesImpl::errors() { return delegate->errors(); } void SpatialSeriesImpl::errors(ErrorList &e) { delegate->errors(e); } FunctorList *SpatialSeriesImpl::subfunctors() { return delegate->subfunctors(); } void SpatialSeriesImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } ReciteImpl::ReciteImpl(uint8_t l, CollectionList *c) : Recite() { delegate = new AggregateImpl((char*)"Recite", l, c); } ReciteImpl::ReciteImpl(CollectionList *c) : Recite() { delegate = new AggregateImpl((char*)"Recite", c); } ReciteImpl::ReciteImpl(uint8_t l, CollectionList *c, unsigned int seq) : Recite() { delegate = new AggregateImpl((char*)"Recite", l, c, seq); } uint8_t ReciteImpl::identifier() { return IOTA; } Series* ReciteImpl::results() { unsigned int count = 0, pos = 0; unsigned int num = delegate->collectors()->length(); for (unsigned int i = 0; i < num; i++) { Collection *c = (*(delegate->collectors()))[i]; count += c->results()->length(); } Series *array = new Series(); array->length(count); for (unsigned int i = 0; i < num; i++) { Collection *c = (*(delegate->collectors()))[i]; if (c->results() != NULL && c->results()->length() > 0) { for (unsigned int j = 0; j < c->results()->length(); j++) { Series *s = c->results(); (*array)[pos] = (*s)[j]; pos++; } } } return array; } char *ReciteImpl::asString() { return delegate->asString(); } unsigned int ReciteImpl::sequencer() { return delegate->sequencer(); } uint8_t ReciteImpl::level() { return delegate->level(); } CollectionList* ReciteImpl::collectors() { return delegate->collectors(); } void ReciteImpl::collectors(CollectionList *c) { delegate->collectors(c); } SensoryList* ReciteImpl::senses() { return delegate->senses(); } Sensory_ptr ReciteImpl::sense() { return delegate->sense(); } void ReciteImpl::sense(Sensory_ptr s) { delegate->sense(s); } uint8_t ReciteImpl::sensor() { return delegate->sensor(); } unsigned long long ReciteImpl::timeused() { return delegate->timeused(); } void ReciteImpl::timeused(unsigned long long t) { delegate->timeused(t); } double ReciteImpl::energyused() { return delegate->energyused(); } void ReciteImpl::energyused(double e) { delegate->energyused(e); } uint8_t ReciteImpl::priority() { return delegate->priority(); } void ReciteImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* ReciteImpl::errors() { return delegate->errors(); } void ReciteImpl::errors(ErrorList &e) { delegate->errors(e); } FunctorList *ReciteImpl::subfunctors() { return delegate->subfunctors(); } void ReciteImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } SumImpl::SumImpl(uint8_t l, CollectionList *c) : Sum() { delegate = new AggregateImpl((char*)"Sum", l, c); } SumImpl::SumImpl(CollectionList *c) : Sum() { delegate = new AggregateImpl((char*)"Sum", c); } SumImpl::SumImpl(uint8_t l, CollectionList *c, unsigned int seq) : Sum() { delegate = new AggregateImpl((char*)"Sum", l, c, seq); } uint8_t SumImpl::identifier() { return SUMMA; } Data* SumImpl::getResult(unsigned int idx) { double value = 0.0; Collection *c = (*(delegate->collectors()))[idx]; Series *s = c->results(); for (unsigned int i = 0; i < s->length(); i++) { Data *d = &((*s)[i]); if (isIntegerData(d->_d())) value += d->iresult(); else if (isFloatingPointData(d->_d())) value += d->fresult(); } Data* ret = new Data(); ret->fresult(value); return ret; } Series* SumImpl::results() { unsigned int num = delegate->collectors()->length(); Series *array = new Series(); array->length(num); for (unsigned int i = 0; i < num; i++) (*array)[i] = *(getResult(i)); return array; } char *SumImpl::asString() { return delegate->asString(); } unsigned int SumImpl::sequencer() { return delegate->sequencer(); } uint8_t SumImpl::level() { return delegate->level(); } CollectionList* SumImpl::collectors() { return delegate->collectors(); } void SumImpl::collectors(CollectionList *c) { delegate->collectors(c); } SensoryList* SumImpl::senses() { return delegate->senses(); } Sensory_ptr SumImpl::sense() { return delegate->sense(); } void SumImpl::sense(Sensory_ptr s) { delegate->sense(s); } uint8_t SumImpl::sensor() { return delegate->sensor(); } unsigned long long SumImpl::timeused() { return delegate->timeused(); } void SumImpl::timeused(unsigned long long t) { delegate->timeused(t); } double SumImpl::energyused() { return delegate->energyused(); } void SumImpl::energyused(double e) { delegate->energyused(e); } uint8_t SumImpl::priority() { return delegate->priority(); } void SumImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* SumImpl::errors() { return delegate->errors(); } void SumImpl::errors(ErrorList &e) { delegate->errors(e); } FunctorList *SumImpl::subfunctors() { return delegate->subfunctors(); } void SumImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } DeltaImpl::DeltaImpl(uint8_t l, CollectionList *c) : Delta() { delegate = new AggregateImpl((char*)"Delta", l, c); } DeltaImpl::DeltaImpl(CollectionList *c) : Delta() { delegate = new AggregateImpl((char*)"Delta", c); } DeltaImpl::DeltaImpl(uint8_t l, CollectionList *c, unsigned int seq) : Delta() { delegate = new AggregateImpl((char*)"Delta", l, c, seq); } uint8_t DeltaImpl::identifier() { return DELTA; } Data* DeltaImpl::getResult(unsigned int idx) { double min = DBL_MAX, max = -(DBL_MAX); double value = 0.0; Collection *c = (*(delegate->collectors()))[idx]; Series *s = c->results(); for (unsigned int i = 0; i < s->length(); i++) { Data *d = &((*s)[i]); if (isIntegerData(d->_d())) { if (d->iresult() > max) max = d->iresult(); if (d->iresult() < min) min = d->iresult(); } else if (isFloatingPointData(d->_d())) { if (d->fresult() > max) max = d->fresult(); if (d->fresult() < min) min = d->fresult(); } } value = max - min; Data* ret = new Data(); ret->fresult(value); return ret; } Series* DeltaImpl::results() { unsigned int num = delegate->collectors()->length(); Series *array = new Series(); array->length(num); for (unsigned int i = 0; i < num; i++) (*array)[i] = *(getResult(i)); return array; } char *DeltaImpl::asString() { return delegate->asString(); } unsigned int DeltaImpl::sequencer() { return delegate->sequencer(); } uint8_t DeltaImpl::level() { return delegate->level(); } CollectionList* DeltaImpl::collectors() { return delegate->collectors(); } void DeltaImpl::collectors(CollectionList *c) { delegate->collectors(c); } SensoryList* DeltaImpl::senses() { return delegate->senses(); } Sensory_ptr DeltaImpl::sense() { return delegate->sense(); } void DeltaImpl::sense(Sensory_ptr s) { delegate->sense(s); } uint8_t DeltaImpl::sensor() { return delegate->sensor(); } unsigned long long DeltaImpl::timeused() { return delegate->timeused(); } void DeltaImpl::timeused(unsigned long long t) { delegate->timeused(t); } double DeltaImpl::energyused() { return delegate->energyused(); } void DeltaImpl::energyused(double e) { delegate->energyused(e); } uint8_t DeltaImpl::priority() { return delegate->priority(); } void DeltaImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* DeltaImpl::errors() { return delegate->errors(); } void DeltaImpl::errors(ErrorList &e) { delegate->errors(e); } FunctorList *DeltaImpl::subfunctors() { return delegate->subfunctors(); } void DeltaImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } MeanImpl::MeanImpl(uint8_t l, CollectionList *c) : Mean() { delegate = new AggregateImpl((char*)"Mean", l, c); } MeanImpl::MeanImpl(CollectionList *c) : Mean() { delegate = new AggregateImpl((char*)"Mean", c); } MeanImpl::MeanImpl(uint8_t l, CollectionList *c, unsigned int seq) : Mean() { delegate = new AggregateImpl((char*)"Mean", l, c, seq); } uint8_t MeanImpl::identifier() { return BARX; } Data* MeanImpl::getResult(unsigned int idx) { double value = 0.0; Collection *c = (*(delegate->collectors()))[idx]; Series *s = c->results(); for (unsigned int i = 0; i < s->length(); i++) { Data *d = &((*s)[i]); if (isIntegerData(d->_d())) value += d->iresult(); else if (isFloatingPointData(d->_d())) value += d->fresult(); } value /= s->length(); Data* ret = new Data(); ret->fresult(value); return ret; } Series* MeanImpl::results() { unsigned int num = delegate->collectors()->length(); Series *array = new Series(); array->length(num); for (unsigned int i = 0; i < num; i++) (*array)[i] = *(getResult(i)); return array; } char *MeanImpl::asString() { return delegate->asString(); } unsigned int MeanImpl::sequencer() { return delegate->sequencer(); } uint8_t MeanImpl::level() { return delegate->level(); } CollectionList* MeanImpl::collectors() { return delegate->collectors(); } void MeanImpl::collectors(CollectionList *c) { delegate->collectors(c); } SensoryList* MeanImpl::senses() { return delegate->senses(); } Sensory_ptr MeanImpl::sense() { return delegate->sense(); } void MeanImpl::sense(Sensory_ptr s) { delegate->sense(s); } uint8_t MeanImpl::sensor() { return delegate->sensor(); } unsigned long long MeanImpl::timeused() { return delegate->timeused(); } void MeanImpl::timeused(unsigned long long t) { delegate->timeused(t); } double MeanImpl::energyused() { return delegate->energyused(); } void MeanImpl::energyused(double e) { delegate->energyused(e); } uint8_t MeanImpl::priority() { return delegate->priority(); } void MeanImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* MeanImpl::errors() { return delegate->errors(); } void MeanImpl::errors(ErrorList &e) { delegate->errors(e); } FunctorList *MeanImpl::subfunctors() { return delegate->subfunctors(); } void MeanImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } SigmaImpl::SigmaImpl(uint8_t l, CollectionList *c) : Sigma() { delegate = new AggregateImpl((char*)"Sigma", l, c); } SigmaImpl::SigmaImpl(CollectionList *c) : Sigma() { delegate = new AggregateImpl((char*)"Sigma", c); } SigmaImpl::SigmaImpl(uint8_t l, CollectionList *c, unsigned int seq) : Sigma() { delegate = new AggregateImpl((char*)"Sigma", l, c, seq); } uint8_t SigmaImpl::identifier() { return SIGMA; } Data* SigmaImpl::getResult(unsigned int idx) { double avg = 0.0; double value = 0.0; Collection *c = (*(delegate->collectors()))[idx]; Series *s = c->results(); for (unsigned int i = 0; i < s->length(); i++) { Data *d = &((*s)[i]); if (isIntegerData(d->_d())) avg += d->iresult(); else if (isFloatingPointData(d->_d())) avg += d->fresult(); } avg /= s->length(); for (unsigned int i = 0; i < s->length(); i++) { Data *d = &((*s)[i]); double dev = 0.0; if (isIntegerData(d->_d())) dev = d->iresult() - avg; else if (isFloatingPointData(d->_d())) dev = d->fresult() - avg; value += (dev * dev); } value /= (s->length() - 1); value = sqrt(value); Data* ret = new Data(); ret->fresult(value); return ret; } Series* SigmaImpl::results() { unsigned int num = delegate->collectors()->length(); Series *array = new Series(); array->length(num); for (unsigned int i = 0; i < num; i++) (*array)[i] = *(getResult(i)); return array; } char *SigmaImpl::asString() { return delegate->asString(); } unsigned int SigmaImpl::sequencer() { return delegate->sequencer(); } uint8_t SigmaImpl::level() { return delegate->level(); } CollectionList* SigmaImpl::collectors() { return delegate->collectors(); } void SigmaImpl::collectors(CollectionList *c) { delegate->collectors(c); } SensoryList* SigmaImpl::senses() { return delegate->senses(); } Sensory_ptr SigmaImpl::sense() { return delegate->sense(); } void SigmaImpl::sense(Sensory_ptr s) { delegate->sense(s); } uint8_t SigmaImpl::sensor() { return delegate->sensor(); } unsigned long long SigmaImpl::timeused() { return delegate->timeused(); } void SigmaImpl::timeused(unsigned long long t) { delegate->timeused(t); } double SigmaImpl::energyused() { return delegate->energyused(); } void SigmaImpl::energyused(double e) { delegate->energyused(e); } uint8_t SigmaImpl::priority() { return delegate->priority(); } void SigmaImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* SigmaImpl::errors() { return delegate->errors(); } void SigmaImpl::errors(ErrorList &e) { delegate->errors(e); } FunctorList *SigmaImpl::subfunctors() { return delegate->subfunctors(); } void SigmaImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } LambdaImpl::LambdaImpl(uint8_t l, CollectionList *c) : Lambda() { delegate = new AggregateImpl((char*)"Lambda", l, c); } LambdaImpl::LambdaImpl(CollectionList *c) : Lambda() { delegate = new AggregateImpl((char*)"Lambda", c); } LambdaImpl::LambdaImpl(uint8_t l, CollectionList *c, unsigned int seq) : Lambda() { delegate = new AggregateImpl((char*)"Lambda", l, c, seq); } uint8_t LambdaImpl::identifier() { return LAMBDA; } char *LambdaImpl::code() { return script; } void LambdaImpl::code(char *s) { char *tmp = script; script = s; CORBA::string_free(tmp); } double LambdaImpl::doScript(double previous, double measure) { // TODO: evaluate using script return measure; } Data* LambdaImpl::getResult(unsigned int idx) { double value = 0.0; Collection *c = (*(delegate->collectors()))[idx]; Series *s = c->results(); for (unsigned int i = 0; i < s->length(); i++) { Data *d = &((*s)[i]); if (isIntegerData(d->_d())) value = doScript(value, d->iresult()); else if (isFloatingPointData(d->_d())) value = doScript(value, d->fresult()); } Data* ret = new Data(); ret->fresult(value); return ret; } Series* LambdaImpl::results() { unsigned int num = delegate->collectors()->length(); Series *array = new Series(); array->length(num); for (unsigned int i = 0; i < num; i++) (*array)[i] = *(getResult(i)); return array; } char *LambdaImpl::asString() { return delegate->asString(); } unsigned int LambdaImpl::sequencer() { return delegate->sequencer(); } uint8_t LambdaImpl::level() { return delegate->level(); } CollectionList* LambdaImpl::collectors() { return delegate->collectors(); } void LambdaImpl::collectors(CollectionList *c) { delegate->collectors(c); } SensoryList* LambdaImpl::senses() { return delegate->senses(); } Sensory_ptr LambdaImpl::sense() { return delegate->sense(); } void LambdaImpl::sense(Sensory_ptr s) { delegate->sense(s); } uint8_t LambdaImpl::sensor() { return delegate->sensor(); } unsigned long long LambdaImpl::timeused() { return delegate->timeused(); } void LambdaImpl::timeused(unsigned long long t) { delegate->timeused(t); } double LambdaImpl::energyused() { return delegate->energyused(); } void LambdaImpl::energyused(double e) { delegate->energyused(e); } uint8_t LambdaImpl::priority() { return delegate->priority(); } void LambdaImpl::priority(uint8_t p) { delegate->priority(p); } ErrorList* LambdaImpl::errors() { return delegate->errors(); } void LambdaImpl::errors(ErrorList &e) { delegate->errors(e); } FunctorList *LambdaImpl::subfunctors() { return delegate->subfunctors(); } void LambdaImpl::subfunctors(FunctorList &fs) { delegate->subfunctors(fs); } LocationImpl::LocationImpl(double latitude, double longitude, double altitude) : Location() { struct timeval tv; have_device = false; lat = latitude; lon = longitude; alt = altitude; gettimeofday(&tv, NULL); now = (tv.tv_sec * 1000000) + tv.tv_usec; } uint8_t LocationImpl::identifier() { return GPS; } double LocationImpl::latitude() { getGPS(); return lat; } double LocationImpl::longitude() { getGPS(); return lon; } double LocationImpl::altitude() { getGPS(); return alt; } unsigned long long LocationImpl::time() { getGPS(); return now; } void LocationImpl::getGPS() { struct timeval tv; gettimeofday(&tv, NULL); now = (tv.tv_sec * 1000000) + tv.tv_usec; } void LocationImpl::acquire(Functor_ptr f) { getGPS(); Series *array = new Series(); array->length(4); (*array)[0].fresult(lat); (*array)[0].fresult(lon); (*array)[0].fresult(alt); (*array)[0].iresult(now); f->results(*array); } PowerImpl::PowerImpl() : Power() { have_device = false; starting_energy = getBattery(); } uint8_t PowerImpl::identifier() { return BATTERY; } double PowerImpl::ratio() { energy_now = getBattery(); return energy_now / starting_energy; } double PowerImpl::getBattery() { return 1.0; } void PowerImpl::acquire(Functor_ptr f) { Series *array = new Series(); array->length(1); (*array)[0].fresult(ratio()); f->results(*array); }

© 2008, Los Alamos National Security, LLC.