Ensemble.h

#ifndef _MSPASS_ENSEMBLE_H_
#define _MSPASS_ENSEMBLE_H_
#include "mspass/seismic/Seismogram.h"
#include "mspass/seismic/TimeSeries.h"
#include "mspass/utility/memory_constants.h"
#include <vector>
 
namespace mspass::seismic {
template <typename Tdata> class Ensemble : public mspass::utility::Metadata {
public:
  std::vector<Tdata> member;
  Ensemble() {};
  Ensemble(const size_t n) { member.reserve(n); };
  Ensemble(const mspass::utility::Metadata &md, const size_t n)
      : mspass::utility::Metadata(md) {
    member.reserve(n);
  };
  Ensemble(const Ensemble &parent)
      : mspass::utility::Metadata(
            dynamic_cast<const mspass::utility::Metadata &>(parent)),
        member(parent.member) {};
  Ensemble &operator=(const Ensemble &parent) {
    if (this != (&parent)) {
      this->Metadata::operator=(parent);
      member = parent.member;
    }
    return *this;
  };
  Tdata &operator[](const size_t n) const try {
    return (this->member[n]);
  } catch (...) {
    throw;
  };
  void update_metadata(const mspass::utility::Metadata &newmd) try {
    mspass::utility::Metadata *md;
    md = dynamic_cast<mspass::utility::Metadata *>(this);
    (*md) += newmd;
  } catch (...) {
    throw;
  };
  void sync_metadata() {
    size_t i;
    for (i = 0; i < this->member.size(); ++i) {
      mspass::utility::Metadata *mdmember = &(this->member[i]);
      (*mdmember) += dynamic_cast<mspass::utility::Metadata &>(*this);
    }
  };
  void sync_metadata(std::vector<std::string> exclude) {
    mspass::utility::Metadata sync_md(*this);
    for (size_t i = 0; i < exclude.size(); i++) {
      if (sync_md.is_defined(exclude[i])) {
        sync_md.erase(exclude[i]);
      }
    }
    for (size_t i = 0; i < this->member.size(); ++i) {
      mspass::utility::Metadata *mdmember = &(this->member[i]);
      (*mdmember) += sync_md;
    }
  };
};
 
template <typename T> class LoggingEnsemble : public Ensemble<T> {
public:
  mspass::utility::ErrorLogger elog;
  LoggingEnsemble() : Ensemble<T>(), elog() { ensemble_is_live = false; };
 
  /* The next two constructors are used to provide a parallel qpi to
  CoreEnsemble - there might be another way to do this in the C++ code or
  in pybind11 wrappers but this works*/
  LoggingEnsemble(const size_t n) : Ensemble<T>(n), elog() {
    ensemble_is_live = false;
  }
  LoggingEnsemble(const mspass::utility::Metadata &md, const size_t n)
      : Ensemble<T>(md, n), elog() {
    /* Might be advised to set this true, but since an object created by
    this method has only slots but no data validate would return false.*/
    ensemble_is_live = false;
  }
  LoggingEnsemble(const mspass::utility::Metadata &md,
                  const mspass::utility::ErrorLogger &elogin,
                  const size_t ndata)
      : Ensemble<T>(md, ndata), elog(elogin) {};
  LoggingEnsemble(const LoggingEnsemble<T> &parent)
      : Ensemble<T>(parent), elog(parent.elog) {
    ensemble_is_live = parent.ensemble_is_live;
  };
  LoggingEnsemble(const Ensemble<T> &parent) : Ensemble<T>(parent), elog() {
    ensemble_is_live = true;
  };
  void kill() { ensemble_is_live = false; };
  bool live() const { return ensemble_is_live; };
  bool dead() const { return !ensemble_is_live; };
  bool validate();
  bool set_live() {
    if (this->validate()) {
      ensemble_is_live = true;
      return true;
    } else
      return false;
  };
 
  LoggingEnsemble<T> &operator=(const LoggingEnsemble<T> &parent) {
    if (&parent != this) {
      this->mspass::utility::Metadata::operator=(parent);
      this->member.reserve(parent.member.size());
      this->member = parent.member;
      elog = parent.elog;
      ensemble_is_live = parent.ensemble_is_live;
    }
    return *this;
  };
  size_t memory_use() const {
    size_t memuse;
    memuse = sizeof(*this);
    for (auto p = this->member.begin(); p != this->member.end(); ++p) {
      memuse += p->memory_use();
    }
    /* Account for ensemble metadata */
    /* We can only estimate the size of the Metadata container.
    These constants are defined in memory_constants.h */
    memuse +=
        mspass::utility::memory_constants::MD_AVERAGE_SIZE * this->md.size();
    memuse += mspass::utility::memory_constants::KEY_AVERAGE_SIZE *
              this->changed_or_set.size();
    /* Account for error log size */
    memuse += mspass::utility::memory_constants::ELOG_AVERAGE_SIZE *
              this->elog.size();
    return memuse;
  };
 
private:
  bool ensemble_is_live;
};
 
template <typename T> bool LoggingEnsemble<T>::validate() {
  for (auto dptr = this->member.begin(); dptr != this->member.end(); ++dptr) {
    if (dptr->live())
      return true;
  }
  return false;
}
 
typedef Ensemble<TimeSeries> TimeSeriesEnsemble;
typedef Ensemble<Seismogram> ThreeComponentEnsemble;
/* Disable temporarily - needs a revision to match new history approach
template <typename Tdata>
  size_t set_inputs(ProcessingHistoryRecord& rec, const
mspass::seismic::Ensemble<Tdata>& d)
{
  try{
    for(size_t i=0;i<d.member.size();++i)
    {
      // Ignore any data not defined as live
      if(d.member[i].live())
      {
        list<ProcessingHistoryRecord> h(d.member[i].history());
        // do nothing if the container is empty
        if(h.size()>0)rec.inputs.push_back(h);
      }
    }
    return rec.inputs.size();
  }catch(...){throw;};
};
*/
} // namespace mspass::seismic
#endif //  End guard