seqgradtrapez.h

/***************************************************************************
                          seqgradtrapez.h  -  description
                             -------------------
    begin                : Tue Apr 27 2004
    copyright            : (C) 2001 by Thies H. Jochimsen
    email                : jochimse@cns.mpg.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

---