seqacqepi.h

/***************************************************************************
                          seqacqepi.h  -  description
                             -------------------
    begin                : Wed Aug 8 2001
    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 SEQACQEPI_H
#define SEQACQEPI_H
 
#include <odinseq/seqacq.h>
#include <odinseq/seqgrad.h>
#include <odinseq/seqlist.h>
#include <odinseq/seqloop.h>
#include <odinseq/seqdelay.h>
#include <odinseq/seqgradtrapez.h>
#include <odinseq/seqgradconst.h>
#include <odinseq/seqparallel.h>
#include <odinseq/seqdriver.h>
 
 
class SeqEpiDriver : public SeqDriverBase, public SeqObjList, public virtual SeqAcqInterface, public virtual SeqGradInterface {
 
 public:
 
  SeqEpiDriver() {}
  virtual ~SeqEpiDriver() {}
 
  virtual void init_driver(const STD_string& object_label,double sweepwidth,
            float kread_min,  float kread_max,  unsigned readntps,
            float kphase_min, float kphase_max, unsigned phasentps,int startindex_phase,
            bool ramp_sampling,rampType rampmode, float ramp_steepness,
            const STD_string& nucleus, const dvector& phaselist, const dvector& freqlist, unsigned int echo_pairs) = 0;
 
  virtual unsigned get_npts_read() const = 0;
 
  virtual unsigned int get_numof_gradechoes() const = 0;
 
  virtual double get_echoduration() const = 0;
 
  virtual double get_ramp_rastertime() const = 0;
 
  virtual float get_gradintegral2center_read() const = 0;
 
  virtual float get_gradintegral2center_phase() const = 0;
 
  virtual fvector get_readout_shape() const = 0;
 
  virtual const kSpaceCoord& get_kcoord_template(unsigned int& padded_zeroes) const = 0;
 
  virtual SeqEpiDriver* clone_driver() const = 0;
 
  unsigned int get_npts() const {return get_npts_read()*get_numof_gradechoes();}
 
 
 protected:
  SeqEpiDriver(const SeqEpiDriver& seda) : SeqObjList(seda)  {SeqEpiDriver::operator = (seda);}
 
  SeqEpiDriver& operator = (const SeqEpiDriver& seda) {
    SeqObjList::operator =(seda);
    return *this;
  }
 
 
};
 
 
 
class SeqEpiDriverDefault :  public SeqEpiDriver {
 
  // virtual functions of SeqFreqChanInterface are marhshalled to adc
 
 public:
  SeqEpiDriverDefault();
  ~SeqEpiDriverDefault() {}
 
  SeqEpiDriverDefault(const SeqEpiDriverDefault& sedi);
 
  void init_driver(const STD_string& object_label,double sweepwidth,
            float kread_min,  float kread_max,  unsigned readntps,
            float kphase_min, float kphase_max, unsigned phasentps,int startindex_phase,
            bool ramp_sampling, rampType rampmode, float ramp_steepness,
            const STD_string& nucleus,
            const dvector& phaselist, const dvector& freqlist, unsigned int echo_pairs);
 
 
  // overloading virtual functions from SeqDriverBase
  odinPlatform get_driverplatform() const {return standalone;}
 
 
  // implemented virtual functions from SeqEpiDriver
  unsigned int get_npts_read() const {return adc.get_npts();}
  unsigned int get_numof_gradechoes() const;
  double get_echoduration() const {return posread.get_gradduration();}
  double get_ramp_rastertime() const {return posread.get_timestep();}
  float get_gradintegral2center_read() const {return gradint2center_read;}
  float get_gradintegral2center_phase() const {return gradint2center_phase;}
  fvector get_readout_shape() const {return readshape;}
  const kSpaceCoord& get_kcoord_template(unsigned int& padded_zeroes) const {padded_zeroes=0; return adc.get_kcoord();}
  SeqEpiDriver* clone_driver() const {return new SeqEpiDriverDefault(*this);}
 
 
  // marshalling virtual functions of SeqAcqInterface to adc, except:
  double get_acquisition_center() const;
  double get_acquisition_start() const;
  SeqAcqInterface& set_template_type(templateType type);
 
 
 
 
  // implementing virtual functions of SeqGradInterface
  SeqGradInterface& set_strength(float gradstrength) {return *this;}
  SeqGradInterface& invert_strength() {kernel.invert_strength(); return *this;}
  float get_strength() const {return kernel.get_strength();}
  fvector get_gradintegral() const;
  double get_gradduration() const {return kernel.get_gradduration();}
  SeqGradInterface& set_gradrotmatrix(const RotMatrix& matrix) {kernel.set_gradrotmatrix(matrix); return *this;}
 
 
 private:
  void build_seq();
 
  SeqAcq adc;
  SeqDelay acqdelay_begin;
  SeqDelay acqdelay_middle;
  SeqDelay acqdelay_end;
 
  SeqGradTrapez posread;
  SeqGradTrapez negread;
 
  SeqGradTrapez phaseblip1st;
  SeqGradTrapez phaseblip2nd;
  SeqGradDelay phasezero1st;
  SeqGradDelay phasezero2nd;
  SeqGradDelay phasezero_lastblip;
 
  SeqGradChanParallel gradkernel;
  SeqGradChanParallel lastgradkernel;
  SeqObjList oneadckernel;
  SeqObjList adckernel;
  SeqObjList lastadckernel;
  SeqParallel kernel;
  SeqParallel lastkernel;
 
  SeqObjLoop loop;
 
  float gradint2center_read;
  float gradint2center_phase;
  int centerindex_phase;
  fvector readshape;
  templateType templtype;
  int echopairs;
  bool lastecho;
};
 
 
 
 
class SeqAcqEPIdephObjs; // forward declaration
 
class SeqAcqEPI : public SeqObjBase, public virtual SeqAcqInterface, public virtual SeqGradInterface  {
 
 public:
 
  SeqAcqEPI(const STD_string& object_label, double sweepwidth,
            unsigned int read_size, float FOVread,
            unsigned int phase_size, float FOVphase,
            unsigned int shots=1, unsigned int reduction=1, float os_factor=1.0, const STD_string& nucleus="",
            const dvector& phaselist=0, const dvector& freqlist=0,
            rampType rampmode = linear, bool ramp_sampling=false, float ramp_steepness=1.0,
            float fourier_factor=0.0, unsigned int echo_pairs=0, bool invert_partial_fourier=false);
 
 
 
  SeqAcqEPI(const SeqAcqEPI& sae);
 
  SeqAcqEPI(const STD_string& object_label="unnamedSeqAcqEPI");
 
  ~SeqAcqEPI();
 
  unsigned int get_npts_read() const {return driver->get_npts_read();}
 
  unsigned int get_numof_gradechoes() const {return driver->get_numof_gradechoes();}
 
  fvector get_readout_shape() const {return driver->get_readout_shape();}
 
  SeqAcqEPI& operator = (const SeqAcqEPI& sae);
 
 
  // forwarding virtual functions of SeqAcqInterface to driver
  // we cannot use marshalling with a fixed pointer here because
  // driver may be changed when switching platform
  double get_acquisition_center() const {return driver->get_acquisition_center();}
  double get_acquisition_start() const {return driver->get_acquisition_start();}
  unsigned int get_npts() const {return driver->get_npts();}
  SeqAcqInterface& set_sweepwidth(double sw, float os_factor); // produce warning
  double get_sweepwidth() const {return driver->get_sweepwidth();}
  float get_oversampling() const {return os_factor_cache;}
  SeqAcqInterface& set_template_type(templateType type);
  SeqAcqInterface& set_reco_vector(recoDim dim, const SeqVector& vec, const dvector& valvec=dvector()) {driver->set_reco_vector(dim,vec,valvec); return *this;}
  SeqAcqInterface& set_default_reco_index(recoDim dim, unsigned int index) {driver->set_default_reco_index(dim,index); return *this;}
 
  // forwarding virtual functions of SeqFreqChanInterface to driver
  SeqFreqChanInterface& set_nucleus(const STD_string& nucleus) {driver->set_nucleus(nucleus); return *this;}
  SeqFreqChanInterface& set_freqlist(const dvector& freqlist) {driver->set_freqlist(freqlist); return *this;}
  SeqFreqChanInterface& set_phaselist(const dvector& phaselist) {driver->set_phaselist(phaselist); return *this;}
  const SeqVector& get_freqlist_vector() const {return driver->get_freqlist_vector();}
  const SeqVector& get_phaselist_vector() const {return driver->get_phaselist_vector();}
 
  // forwarding virtual functions of SeqGradInterface to driver
  SeqGradInterface& set_strength(float gradstrength) {driver->set_strength(gradstrength); return *this;}
  SeqGradInterface& invert_strength() {driver->invert_strength(); return *this;}
  float get_strength() const {return driver->get_strength();}
  fvector get_gradintegral() const {return driver->get_gradintegral();}
  double get_gradduration() const {return driver->get_gradduration();}
  SeqGradInterface& set_gradrotmatrix(const RotMatrix& matrix) {driver->set_gradrotmatrix(matrix); return *this;}
 
 
  // forwarding virtual functions of SeqTreeObj to driver
  STD_string get_program(programContext& context) const {return driver->get_program(context);}
  double get_duration() const {return driver->get_duration();}
  SeqValList get_freqvallist(freqlistAction action) const {return driver->get_freqvallist(action);}
  void query(queryContext& context) const {driver->query(context);}
  RecoValList get_recovallist(unsigned int reptimes, LDRkSpaceCoords& coords) const;
  bool contains(const SeqTreeObj* sto) const {return driver->contains(sto);}
  void tree(SeqTreeCallbackAbstract* display) const {driver->tree(display);}
  unsigned int event(eventContext& context) const {return driver->event(context);}
  STD_string get_properties() const {return driver->get_properties();}
 
 
 private:
 
  SeqVector& get_mutable_freqlist_vector() {return driver->get_mutable_freqlist_vector();}
  SeqVector& get_mutable_phaselist_vector() {return driver->get_mutable_phaselist_vector();}
 
  // overloaded for SeqAcqDeph
  const SeqVector* get_dephgrad(SeqGradChanParallel& dephobj, bool rephase) const;
 
  // overwriting virtual functions from SeqClass
  bool prep();
 
  void common_init();
 
  void create_deph_and_reph();
 
 
  unsigned int readsize_os_cache;
  float os_factor_cache;
  unsigned int phasesize_cache;
  unsigned int segments_cache;
  unsigned int reduction_cache;
  int echo_pairs_cache;
  float blipint_cache;
  templateType templtype_cache;
  rampType ramptype_cache;
 
  mutable SeqDriverInterface<SeqEpiDriver> driver;
 
  SeqAcqEPIdephObjs* dephobjs;
};
 
 
#endif