seqgradtrapez.h

/***************************************************************************
                          seqgradtrapez.h  -  description
                             -------------------
    begin                : Tue Apr 27 2004
    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 SEQGRADTRAPEZ_H
#define SEQGRADTRAPEZ_H
 
#include <odinseq/seqgradchanlist.h>
#include <odinseq/seqgradchanparallel.h>
#include <odinseq/seqgradramp.h>
#include <odinseq/seqdriver.h>
 
 
 
 
class SeqGradTrapezDriver : public SeqDriverBase {
 
 public:
  SeqGradTrapezDriver() {}
  virtual ~SeqGradTrapezDriver() {}
 
  virtual bool update_driver(direction channel, double onrampdur, double constdur, double offrampdur, float strength, double timestep, rampType type, bool exclude_offramp_from_timing) = 0;
 
  virtual float get_onramp_integral (double tmin, double tmax) const = 0;
  virtual float get_offramp_integral(double tmin, double tmax) const = 0;
 
  virtual const fvector& get_onramp()  const = 0;
  virtual const fvector& get_offramp() const = 0;
 
  virtual SeqGradChanList get_driverchanlist() = 0;
 
  virtual bool check_ramptype(rampType type) const = 0;
 
  virtual SeqGradTrapezDriver* clone_driver() const = 0;
};
 
 
class SeqGradTrapezDefault : public SeqGradTrapezDriver, public SeqGradChan {
 
 public:
 
  SeqGradTrapezDefault();
 
  SeqGradTrapezDefault(const SeqGradTrapezDefault& sgtd);
 
  ~SeqGradTrapezDefault() {}
 
 
  // overloading virtual functions from SeqGradTrapezDriver
  bool update_driver(direction channel, double onrampdur, double constdur, double offrampdur, float strength, double timestep, rampType type, bool exclude_offramp_from_timing);
  float get_onramp_integral (double tmin, double tmax) const {return onramp_cache. get_integral(tmin,tmax);}
  float get_offramp_integral(double tmin, double tmax) const {return offramp_cache.get_integral(tmin,tmax);}
  const fvector& get_onramp()  const {return onramp_cache.get_wave();}
  const fvector&  get_offramp() const {return offramp_cache.get_wave();}
  SeqGradChanList get_driverchanlist();
  bool check_ramptype(rampType type) const {return true;}
  SeqGradTrapezDriver* clone_driver() const {return new SeqGradTrapezDefault(*this);}
 
  // overloading virtual functions from SeqDriverBase
  odinPlatform get_driverplatform() const {return standalone;}
 
 private:
  // overwriting virtual functions from SeqClass
  bool prep();
 
  // overloading virtual function from SeqTreeObj
  STD_string get_properties() const;
 
  // overloading virtual functions from SeqGradInterface
  SeqGradInterface& set_strength(float gradstrength);
  SeqGradInterface& invert_strength();
  float get_strength() const {return onramp_cache.get_strength();}
  double get_gradduration() const;
  SeqGradInterface& set_gradrotmatrix(const RotMatrix& matrix);
 
 
  // overloading virtual functions from SeqGradChan
  STD_string get_grdpart(float matrixfactor) const {return graddriver->get_trapez_program(get_strength(),matrixfactor);}
  SeqGradChan& get_subchan(double starttime, double endtime) const;
  direction get_channel() const {return onramp_cache.get_channel();}
  float get_integral() const;
 
  SeqGradRamp onramp_cache;
  SeqGradRamp offramp_cache;
 
  double const_dur;
  bool exclude_offramp;
 
};
 
 
 
 
class SeqGradTrapez : public SeqGradChanList {
 
 public:
 
  SeqGradTrapez(const STD_string& object_label,direction gradchannel,
               float gradstrength, double constgradduration, double timestep=0.01,
               rampType type = linear, double minrampduration=0.0, float steepness=1.0);
 
  SeqGradTrapez(const STD_string& object_label,float gradintegral,
               direction gradchannel, double constgradduration,
               double timestep=0.01, rampType type = linear, double minrampduration=0.0, float steepness=1.0);
 
 
  SeqGradTrapez(const STD_string& object_label,float gradintegral,
               float gradstrength, direction gradchannel,
               double timestep=0.01, rampType type = linear, double minrampduration=0.0, float steepness=1.0);
 
 
  SeqGradTrapez(const SeqGradTrapez& sgt);
 
  SeqGradTrapez(const STD_string& object_label = "unnamedSeqGradTrapez");
 
  SeqGradTrapez& operator = (const SeqGradTrapez& sgt);
 
 
  SeqGradTrapez& set_constgrad_duration(double duration);
 
  double get_onramp_duration() const {return onrampdur;}
 
 
  double get_constgrad_duration() const {return constdur;}
 
 
  double get_offramp_duration() const {return offrampdur;}
 
 
  float get_onramp_integral(double tmin, double tmax) const {return trapezdriver->get_onramp_integral(tmin,tmax);}
 
  float get_onramp_integral() const {return get_onramp_integral(0.0,get_onramp_duration());}
 
  float get_constgrad_integral() const {return constdur*trapezstrength;}
 
  float get_offramp_integral(double tmin, double tmax) const {return trapezdriver->get_offramp_integral(tmin,tmax);}
 
  float get_offramp_integral() const {return get_offramp_integral(0.0,get_offramp_duration());}
 
  SeqGradTrapez& set_integral(float gradintegral);
 
  float get_integral() const;
 
  unsigned int get_onramp_npts() const;
 
  unsigned int get_const_npts() const;
 
  unsigned int get_offramp_npts() const;
 
  unsigned int get_npts() const;
 
 
  fvector get_onramp() const {return trapezdriver->get_onramp();}
 
  fvector get_offramp() const {return trapezdriver->get_offramp();}
 
  fvector get_trapezshape() const;
 
  double get_timestep() const {return dt;}
 
  rampType get_ramptype() const {return rampMode;}
 
  SeqGradTrapez& exclude_offramp_from_timing(bool flag);
 
 
  // overloading virtual function from SeqGradInterface
  float get_strength() const {return trapezstrength;}
  double get_gradduration() const {return get_onramp_duration()+get_constgrad_duration()+get_offramp_duration();} // override result of SeqGradChanList which may differ due to concatenating other SeqGradChans
 
 
 private:
  void common_init();
 
  void check_platform();
  void update_driver();
  void build_seq();
 
  static void get_ramps(const STD_string& label, float& rampintegral, double& rampondur, double& rampoffdur, float strength, double dwelltime, rampType ramptype, float steepness, double mindur);
 
 
  mutable SeqDriverInterface<SeqGradTrapezDriver> trapezdriver;
 
  rampType rampMode;
  double dt;
  float steepnessfactor;
  bool exclude_offramp_timing;
 
  direction trapezchannel;
  double onrampdur;
  double constdur;
  double offrampdur;
  float trapezstrength;
};
 
 
 
class SeqGradTrapezParallel : public SeqGradChanParallel {
 
 public:
 
  SeqGradTrapezParallel(const STD_string& object_label,
               float gradintegral_read, float gradintegral_phase, float gradintegral_slice,
               float maxgradstrength, double timestep=0.01,
               rampType type = linear, double minrampduration=0.0);
 
  SeqGradTrapezParallel(const SeqGradTrapezParallel& sgtp);
 
  SeqGradTrapezParallel(const STD_string& object_label = "unnamedSeqGradTrapezParallel");
 
  SeqGradTrapezParallel& operator = (const SeqGradTrapezParallel& sgtp);
 
 
 private:
  void build_seq();
 
  SeqGradTrapez readgrad;
  SeqGradTrapez phasegrad;
  SeqGradTrapez slicegrad;
 
 
};
 
#endif