seqfreq.h

/***************************************************************************
                          seqfreq.h  -  description
                             -------------------
    begin                : Wed Aug 14 2002
    copyright            : (C) 2000-2021 by Thies H. Jochimsen
    email                : thies@jochimsen.de
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
 
 
#ifndef SEQFREQ_H
#define SEQFREQ_H
 
#include <odinseq/seqclass.h>
#include <odinseq/seqvec.h>
#include <odinseq/seqphase.h>
#include <odinseq/seqdriver.h>
 
 
 
class SeqFreqChanInterface : public virtual SeqClass  {
 
 public:
  virtual SeqFreqChanInterface& set_nucleus(const STD_string& nucleus) {if(marshall) marshall->set_nucleus(nucleus); else marshall_error(); return *this;}
 
 
  virtual SeqFreqChanInterface& set_freqlist(const dvector& freqlist) {if(marshall) marshall->set_freqlist(freqlist); else marshall_error(); return *this;}
 
  virtual SeqFreqChanInterface& set_phaselist(const dvector& phaselist) {if(marshall) marshall->set_phaselist(phaselist); else marshall_error(); return *this;}
 
  virtual const SeqVector& get_freqlist_vector() const {if(marshall) return marshall->get_freqlist_vector(); else marshall_error(); return get_dummyvec();}
 
 
  virtual const SeqVector& get_phaselist_vector() const {if(marshall) return marshall->get_phaselist_vector(); else marshall_error(); return get_dummyvec();}
 
  operator const SeqVector& () const {return get_freqlist_vector();}
 
  virtual SeqFreqChanInterface& set_encoding_scheme(encodingScheme scheme) {if(marshall) marshall->get_mutable_freqlist_vector().set_encoding_scheme(scheme); else marshall_error(); return *this;}
 
  virtual SeqFreqChanInterface& set_reorder_scheme(reorderScheme scheme, unsigned int nsegments=1) {if(marshall) marshall->get_mutable_freqlist_vector().set_reorder_scheme(scheme,nsegments); else marshall_error(); return *this;}
 
  virtual const SeqVector& get_reorder_vector() const {if(marshall) return marshall->get_freqlist_vector().get_reorder_vector(); else marshall_error(); return get_dummyvec();}
 
  virtual SeqFreqChanInterface& set_phaselist_encoding_scheme(encodingScheme scheme) {if(marshall) marshall->get_mutable_phaselist_vector().set_encoding_scheme(scheme); else marshall_error(); return *this;}
 
  virtual SeqFreqChanInterface& set_phaselist_reorder_scheme(reorderScheme scheme, unsigned int nsegments=1) {if(marshall) marshall->get_mutable_phaselist_vector().set_reorder_scheme(scheme,nsegments); else marshall_error(); return *this;}
 
  virtual const SeqVector& get_phaselist_reorder_vector() const {if(marshall) return marshall->get_phaselist_vector().get_reorder_vector(); else marshall_error(); return get_dummyvec();}
 
 
  SeqFreqChanInterface& set_freqoffset(double freqoffset);
 
  SeqFreqChanInterface& set_phase(double phaseval);
 
  SeqFreqChanInterface& set_phasespoiling(unsigned int size=80, double incr=117.0, double offset=0.0);
 
 protected:
  SeqFreqChanInterface() {}
  virtual ~SeqFreqChanInterface() {}
 
  void set_marshall(SeqFreqChanInterface* mymarshall) {marshall=mymarshall;} // to be used in constructor code
 
 private:
  friend class SeqAcqEPI; // to allow SeqAcqEPI full access to its driver
 
  SeqFreqChanInterface* marshall; // for marshalling member functions to a sub-object
 
 
  virtual SeqVector& get_mutable_freqlist_vector() {if(marshall) return marshall->get_mutable_freqlist_vector(); else marshall_error(); return get_dummyvec();}
  virtual SeqVector& get_mutable_phaselist_vector() {if(marshall) return marshall->get_mutable_phaselist_vector(); else marshall_error(); return get_dummyvec();}
 
};
 
 
 
class SeqFreqChanDriver : public SeqDriverBase {
 
 public:
  SeqFreqChanDriver() {}
  virtual ~SeqFreqChanDriver() {}
 
  virtual bool prep_driver(const STD_string& nucleus, const dvector& freqlist) = 0;
  virtual void prep_iteration(double current_frequency, double current_phase, double freqchan_duration) const = 0;
  virtual int get_channel() const = 0;
 
  virtual STD_string get_iteratorcommand(objCategory cat,int freqlistindex) const = 0;
  virtual svector get_freqvec_commands(const STD_string& iterator, const STD_string& instr) const = 0;
 
  virtual STD_string get_pre_program(programContext& context, objCategory cat, const STD_string& instr_label, double default_frequency, double default_phase) const = 0;
 
 
  virtual SeqFreqChanDriver* clone_driver() const = 0;
 
  virtual void pre_event (eventContext& context,double starttime) const = 0;
  virtual void post_event(eventContext& context,double starttime) const = 0;
};
 
 
class SeqFreqChan : public SeqVector, public virtual SeqFreqChanInterface {
 
 public:
  SeqFreqChan(const STD_string& object_label="unnamedSeqFreqChan");
 
 
  SeqFreqChan(const STD_string& object_label,const STD_string& nucleus,
                  const dvector& freqlist=0,const dvector& phaselist=0);
 
 
  SeqFreqChan(const SeqFreqChan& sfc);
 
 
  virtual ~SeqFreqChan() {}
 
 
  SeqFreqChan& operator = (const SeqFreqChan& sfc);
 
 
  int get_channel() const {return freqdriver->get_channel();}
 
 
  dvector get_freqlist() const {return frequency_list;}
 
 
  double get_phase() const {return phaselistvec.get_phase();}
 
 
  virtual double get_frequency() const;
 
 
  unsigned int get_phaselistindex() const {return phaselistvec.get_phaselistindex();}
 
 
  virtual unsigned int get_freqlistindex() const {return 1;}
 
 
  STD_string get_iteratorcommand(objCategory cat) const;
 
 
 
  // overloaded virtual functions of SeqFreqChanInterface
  SeqFreqChanInterface& set_nucleus(const STD_string& nucleus);
  SeqFreqChanInterface& set_freqlist (const dvector& freqlist) {frequency_list=freqlist; return *this;}
  SeqFreqChanInterface& set_phaselist(const dvector& phaselist) {phaselistvec.set_phaselist(phaselist); return *this;}
  const SeqVector& get_freqlist_vector() const {return *this;}
  const SeqVector& get_phaselist_vector() const {return phaselistvec;}
 
 
  // overloaded virtual functions of SeqVector
  unsigned int get_vectorsize() const {return frequency_list.size();}
  bool prep_iteration() const;
  bool is_qualvector() const {return false;}
  svector get_vector_commands(const STD_string& iterator) const {return freqdriver->get_freqvec_commands(iterator,get_driver_instr_label());}
 
  // overloaded functions for SeqTreeObj
  SeqValList get_freqvallist(freqlistAction action) const;
 
 
 protected:
 
  STD_string get_pre_program(programContext& context, objCategory cat, const STD_string& instr_label) const;
 
  void pre_event (eventContext& context,double starttime) const {freqdriver->pre_event(context,starttime);}
  void post_event(eventContext& context,double starttime) const {freqdriver->post_event(context,starttime);}
 
  virtual double get_freqchan_duration() const {return 0.0;}
 
  // overwriting virtual functions from SeqClass
  bool prep();
 
 private:
  friend class SeqPhaseListVector;
 
  // overloaded virtual functions of SeqFreqChanInterface
  SeqVector& get_mutable_freqlist_vector() {return *this;}
  SeqVector& get_mutable_phaselist_vector() {return phaselistvec;}
 
 
  double get_default_phase() const {return closest2zero(phaselistvec.get_phaselist());}
  double get_default_frequency() const {return closest2zero(frequency_list);}
 
  static double closest2zero(const dvector& v);
 
  // for EPIC
  virtual STD_string get_driver_instr_label() const {return "";}
 
 
  // the hardware driver
  mutable SeqDriverInterface<SeqFreqChanDriver> freqdriver;
 
  // the nucleus of this freq/phase object
  STD_string nucleusName;
 
  // the frequency list to iterate through
  dvector frequency_list;
 
  // the phaselist associated with this freq/phase object
  SeqPhaseListVector phaselistvec;
};
 
 
#endif