seqacq.h

/***************************************************************************
                          seqacq.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 SEQACQ_H
#define SEQACQ_H
 
#include <tjutils/tjhandler.h>
 
#include <odinseq/seqobj.h>
#include <odinseq/seqfreq.h>
#include <odinseq/seqvec.h>
#include <odinseq/seqdriver.h>
 
 
class SeqGradChanParallel; // forward declaration
 
 
 
class SeqAcqInterface : public virtual SeqFreqChanInterface {
 
 public:
 
  virtual double get_acquisition_duration() const {if(marshall) return marshall->get_acquisition_duration(); else marshall_error(); return 0.0;}
 
  virtual double get_acquisition_center() const {if(marshall) return marshall->get_acquisition_center(); else marshall_error(); return 0.0;}
 
  virtual double get_acquisition_start() const {if(marshall) return marshall->get_acquisition_start(); else marshall_error(); return 0.0;}
 
 
  virtual unsigned int get_npts() const {if(marshall) return marshall->get_npts(); else marshall_error(); return 0;}
 
 
 
 
  virtual SeqAcqInterface& set_sweepwidth(double sw, float os_factor) {if(marshall) marshall->set_sweepwidth(sw,os_factor); else marshall_error(); return *this;}
 
 
  virtual double get_sweepwidth() const {if(marshall) return marshall->get_sweepwidth(); else marshall_error(); return 0.0;}
 
  virtual float get_oversampling() const {if(marshall) return marshall->get_oversampling(); else marshall_error(); return 0.0;}
 
 
 
  virtual SeqAcqInterface& set_readout_shape(const fvector& shape, unsigned int dstsize) {if(marshall) marshall->set_readout_shape(shape, dstsize); else marshall_error(); return *this;}
 
 
  virtual SeqAcqInterface& set_reco_vector(recoDim dim, const SeqVector& vec, const dvector& valvec=dvector()) {if(marshall) marshall->set_reco_vector(dim, vec, valvec); else marshall_error(); return *this;}
 
 
 
  virtual SeqAcqInterface& set_default_reco_index(recoDim dim, unsigned int index) {if(marshall) marshall->set_default_reco_index(dim, index); else marshall_error(); return *this;}
 
 
  virtual SeqAcqInterface& set_template_type(templateType type)  {if(marshall) marshall->set_template_type(type); return set_default_reco_index(templtype,type);}
 
 
  virtual SeqAcqInterface& set_reflect_flag(bool flag)  {if(marshall) marshall->set_reflect_flag(flag); else marshall_error(); return *this;}
 
 
 
 protected:
  SeqAcqInterface() : marshall(0) {}
  virtual ~SeqAcqInterface() {}
 
  void set_marshall(SeqAcqInterface* mymarshall) {marshall=mymarshall;} // to be used in constructor code
 
 private:
  friend class SeqAcqDeph;
 
  // to be used by SeqAcqDeph to retrieve pre-dephasing gradients from acquisition object.
  // Overload this function if your acq needs pre-dephasers, return them by appending them to 'dephobj'.
  // Returns any possible vector object as the return value.
  virtual const SeqVector* get_dephgrad(SeqGradChanParallel& dephobj, bool rephase) const {if(marshall) return marshall->get_dephgrad(dephobj,rephase); return 0;}
 
  SeqAcqInterface* marshall; // for marshalling member functions to a sub-object
 
};
 
 
 
 
 
class SeqAcqDriver : public SeqDriverBase {
 
 public:
  SeqAcqDriver() {}
  virtual ~SeqAcqDriver() {}
 
  virtual double adjust_sweepwidth(double desired_sweep_widht) const = 0;
 
  virtual bool prep_driver(kSpaceCoord& recoindex, double sweepwidth, unsigned int nAcqPoints, double acqcenter, int freqchannel) = 0;
 
  virtual double get_predelay() const = 0;
 
  virtual double get_postdelay(double sweepwidth) const = 0;
 
  virtual void event(eventContext& context, double start) const = 0;
 
  virtual STD_string get_program(programContext& context, unsigned  int phaselistindex) const = 0;
 
  virtual STD_string get_instr_label() const = 0;
 
  virtual unsigned int get_numof_channels() const = 0;
 
  virtual SeqAcqDriver* clone_driver() const = 0;
};
 
 
 
 
class SeqAcq : public virtual SeqAcqInterface, public SeqObjBase, public SeqFreqChan {
 
 public:
 
  SeqAcq(const STD_string& object_label, unsigned int nAcqPoints, double sweepwidth,
                              float os_factor=1.0, const STD_string& nucleus="",
                              const dvector& phaselist=0,const dvector& freqlist=0);
 
 
 
  SeqAcq(const SeqAcq& sa);
 
  SeqAcq(const STD_string& object_label="unnamedSeqAcq");
 
  ~SeqAcq();
 
 
  SeqAcq& set_npts(unsigned int nAcqPoints);
 
 
  double get_sweep_width() const {return sweep_width;}
 
 
  SeqAcq& operator = (const SeqAcq& sa);
 
 
  void set_kspace_traj(const farray& kspaceTraj);
 
 
  void set_weight_vec(const cvector& weightVec);
 
 
  SeqAcq& set_rel_center(double relative_kspace_center) {rel_center=relative_kspace_center; return *this;}
 
 
  const kSpaceCoord& get_kcoord() const;
 
 
  // overwriting virtual functions of SeqAcqInterface
  double get_acquisition_duration() const {return secureDivision(npts,sweep_width);}
  double get_acquisition_center() const;
  double get_acquisition_start() const {return acqdriver->get_predelay();}
  unsigned int get_npts() const {return npts;}
  SeqAcqInterface& set_sweepwidth(double sw, float os_factor);
  double get_sweepwidth() const {return sweep_width;}
  float get_oversampling() const {return oversampl;}
  SeqAcqInterface& set_readout_shape(const fvector& shape, unsigned int dstsize);
  SeqAcqInterface& set_reco_vector(recoDim dim, const SeqVector& vec, const dvector& valvec=dvector());
  SeqAcqInterface& set_default_reco_index(recoDim dim, unsigned int index);
  SeqAcqInterface& set_reflect_flag(bool flag) {reflect_flag=flag; return *this;}
 
 
  // overwriting virtual functions of SeqTreeObj
  STD_string get_program(programContext& context) const;
  double get_duration() const;
  SeqValList get_freqvallist(freqlistAction action) const;
  void query(queryContext& context) const {SeqTreeObj::query(context); context.numof_acqs=1;}
  RecoValList get_recovallist(unsigned int reptimes, LDRkSpaceCoords& coords) const;
  unsigned int event(eventContext& context) const;
  STD_string get_properties() const;
 
 private:
  friend class SeqMethod;
  friend class SeqEpiDriverParavision;
  friend class SeqEpiDriverEpic;
 
  void common_init();
 
 
  // overwriting virtual functions of SeqFreqChan
  double get_freqchan_duration() const {return get_acquisition_duration();}
  STD_string get_driver_instr_label() const {return acqdriver->get_instr_label();}
 
 
  // overwriting virtual functions of SeqClass
  bool prep();
 
 
  mutable kSpaceCoord kcoord;
 
  mutable SeqDriverInterface<SeqAcqDriver> acqdriver;
 
  double sweep_width;
  unsigned int npts;
  float oversampl;
  double rel_center;
  bool reflect_flag;
  int readoutIndex;
  int trajIndex;
  int weightIndex;
 
  // safe pointers to vectors to create indices for the ADC
  // pointer to pointer is used here to avoid delete[] bug in GCC2.9
  Handler<const SeqVector*>** dimvec;
 
  int default_recoindex[n_recoIndexDims];
 
 
};
 
#endif