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;
  };
  /* \brief Indexing operator.
 
  This is the indexing operator used to extract an ensemble member
  with a (simpler) construct like x=e[i] as opposed to x=e.member[i].
  The later is possible because we (intionally) make the member Container
  public, but this operator can be used to write code that follows common
  guidelines to not make data public.   It will be used for the python
  interface.
 
  \param n  is the member to be extracted and returned.
  */
  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