odinpulse.h

/***************************************************************************
                          odinpulse.h  -  description
                             -------------------
    begin                : Tue Jun 4 2002
    copyright            : (C) 2000-2021 by Thies 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 ODINPULSE_H
#define ODINPULSE_H
 
#include <odinpara/ldrfunction.h>
#include <odinpara/ldrfilter.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 LDRtrajectory : public LDRfunction,  public StaticHandler<LDRtrajectory> {
 
 public:
  LDRtrajectory(const STD_string& ldrlabel="unnamedLDRtrajectory") : LDRfunction(trajFunc,ldrlabel) {}
 
  LDRtrajectory(const LDRtrajectory& jt) : LDRfunction(jt) {}
 
  LDRtrajectory& operator = (const LDRtrajectory& jt) {LDRfunction::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 LDRshape : public LDRfunction,  public StaticHandler<LDRshape> {
 
 public:
  LDRshape(const STD_string& ldrlabel="unnamedLDRshape") : LDRfunction(shapeFunc,ldrlabel) {}
 
  LDRshape(const LDRshape& js) : LDRfunction(js) {}
 
  LDRshape& operator = (const LDRshape& js) {LDRfunction::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 LDRblock, 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 LDRblock
  int load(const STD_string& filename, const LDRserBase& serializer=LDRserJDX());
 
 
 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