odinpulse.h

/***************************************************************************
                          odinpulse.h  -  description
                             -------------------
    begin                : Tue Jun 4 2002
    copyright            : (C) 2002 by Thies 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 ODINPULSE_H
#define ODINPULSE_H

#include <odinpara/jdxfunction.h>
#include <odinpara/jdxfilter.h>

#include <odinseq/seqpuls.h>


class SeqSimAbstract;  // forward declaration
class Sample;  // forward declaration



#define _BOUNDARY_VALUE_                   0.005
#define _SETREFGAIN_ADIABATIC_INTERVAL_    0.01
#define _SETREFGAIN_ADIABATIC_INCR_FACTOR_ 1.1
#define _SETREFGAIN_ITERATIONS_            3

 // Parameter values of this optimization parameter must be in range [0,1]
#define _TRAJ_OPTIMIZE_PARLABEL_           "FreeParameter"


class JDXtrajectory : public JDXfunction,  public StaticHandler<JDXtrajectory> {

 public:
  JDXtrajectory(const STD_string& jdxlabel="unnamedJDXtrajectory") : JDXfunction(trajFunc,jdxlabel) {}

  JDXtrajectory(const JDXtrajectory& jt) : JDXfunction(jt) {}

  JDXtrajectory& operator = (const JDXtrajectory& jt) {JDXfunction::operator = (jt); return *this;}

  void init_trajectory(OdinPulse* pls=0) {if(allocated_function) allocated_function->init_trajectory(pls);}

  const kspace_coord& calculate(float s) const;

  const traj_info& get_traj_info() const;

  static void init_static();
  static void destroy_static();
};



class JDXshape : public JDXfunction,  public StaticHandler<JDXshape> {

 public:
  JDXshape(const STD_string& jdxlabel="unnamedJDXshape") : JDXfunction(shapeFunc,jdxlabel) {}

  JDXshape(const JDXshape& js) : JDXfunction(js) {}

  JDXshape& operator = (const JDXshape& js) {JDXfunction::operator = (js); return *this;}

  void init_shape() {if(allocated_function) allocated_function->init_shape();}

  STD_complex calculate(const kspace_coord& coord ) const;
  STD_complex calculate(float s, float Tp) const;

  const shape_info& get_shape_info() const;
  farray get_excitation_mask(float fov, unsigned int size) const;


  static void init_static();
  static void destroy_static();
};




struct OdinPulseData; // forward declaration



class OdinPulse : public JcampDxBlock, public virtual SeqClass {

 public:

  OdinPulse(const STD_string& pulse_label="unnamedOdinPulse",bool interactive=false);

  OdinPulse(const OdinPulse& pulse);


  virtual ~OdinPulse();

  OdinPulse& operator = (const OdinPulse& pulse);

  OdinPulse& set_dim_mode(funcMode dmode);

  funcMode get_dim_mode() const;

  unsigned int get_size() const;


  OdinPulse& resize(unsigned int newsize);

  OdinPulse& set_Tp(double duration);

  double get_Tp() const;

  OdinPulse& set_consider_system_cond(bool flag);

  bool get_consider_system_cond() const;



  OdinPulse& set_consider_Nyquist_cond(bool flag);

  bool get_consider_Nyquist_cond() const;



  OdinPulse& set_spat_resolution(double sigma);

  OdinPulse& use_min_spat_resolution(bool flag);

  double get_spat_resolution() const;

  OdinPulse& set_field_of_excitation(double fox);

  double get_field_of_excitation() const;

  OdinPulse& set_spatial_offset(direction direction, double offset);

  double get_spatial_offset(direction direction) const;

  OdinPulse& set_nucleus(const STD_string& nucleusname);

  STD_string get_nucleus() const;

  OdinPulse& set_pulse_type(pulseType type);

  pulseType get_pulse_type() const;

  OdinPulse& set_composite_pulse(const STD_string& cpstring);

  farray get_composite_pulse_parameters() const;

  bool is_composite_pulse() const;

  unsigned int get_numof_composite_pulse() const;

  bool is_adiabatic() const;


  float get_rel_center() const;

  double get_pulse_gain() const;

  float get_flipangle_corr_factor() const;

  OdinPulse& set_flipangle(double angle);

  double get_flipangle() const;

  OdinPulse& generate();

  OdinPulse& set_pulse_gain();


  virtual OdinPulse& update();


  float get_power_depos() const;


  OdinPulse& set_shape(const STD_string& shapeval);



  OdinPulse& set_trajectory(const STD_string& shapeval);


  OdinPulse& set_filter(const STD_string& shapeval);


  OdinPulse& set_shape_parameter(const STD_string& parameter_label, const STD_string& value);

  OdinPulse& set_trajectory_parameter(const STD_string& parameter_label, const STD_string& value);

  OdinPulse& set_filter_parameter(const STD_string& parameter_label, const STD_string& value);

  STD_string get_shape_parameter(const STD_string& parameter_label) const;

  STD_string get_trajectory_parameter(const STD_string& parameter_label) const;

  STD_string get_filter_parameter(const STD_string& parameter_label) const;


  STD_string get_shape() const;

  STD_string get_trajectory() const;

  STD_string get_filter() const;

  const fvector& get_Grad(direction channel) const;

  double get_G0() const;

  const cvector& get_B1() const;

  double get_B10() const;

  void simulate_pulse(SeqSimAbstract& sim, const Sample& sample) const;

  int write_rf_waveform (const STD_string& filename) const;

  int load_rf_waveform (const STD_string& filename);


  // overloading virtual functions of JcampDxBlock
  int load(const STD_string& filename);
  int write(const STD_string& filename) const;


 protected:
  virtual void update_B10andPower();

  OdinPulse& recalc_pulse();

  double get_Tp_1pulse() const;

 private:
  int append_all_members();

  static float ensure_unit_range(float x);

  OdinPulse& make_composite_pulse();


  static float gradient_system_max (const fvector& Gvec, float Gmax, float maxslew, float Tp);
  static float max_kspace_step(const fvector& Gz,float gamma,float Tp,float G0);
  static float max_kspace_step2(const fvector& Gx, const fvector& Gy, float gamma,float Tp,float G0);

  OdinPulse& resize_noupdate(unsigned int newsize);


  // this pointer holds all data of the pulse
  OdinPulseData* data;

};

#endif

---