system.h

/***************************************************************************
                          system.h  -  description
                             -------------------
    begin                : Wed Jun 29 2005
    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 SYSTEM_H
#define SYSTEM_H
 
#include <tjutils/tjhandler.h>
 
#include <odinpara/ldrblock.h>
#include <odinpara/ldrnumbers.h>
#include <odinpara/ldrarrays.h>
#include <odinpara/odinpara.h>
 
 
// defaults for systemInfo
#define _DEFAULT_B0_                  3000 // 3 Tesla
#define _DEFAULT_MAX_SYSTEM_GRADIENT_ 0.04
#define _DEFAULT_MAX_SYSTEM_SLEWRATE_ 0.2
 
 
enum odinPlatform {standalone=0, paravision, numaris_4, epic, numof_platforms};
 
enum objCategory {unknownObj=0,delayObj,pulsObj,gradObj,loopObj,acqObj,freqObj,syncObj,endObj};
 
 
class Nuclei {
 
 public:
  Nuclei();
 
  double get_gamma(const STD_string& nucName) const;
 
  double get_nuc_freq(const STD_string& nucName,float B0) const;
 
 
  LDRenum get_nuc_enum() const;
 
 private:
  typedef STD_pair<STD_string, double> Nucleus;
  typedef STD_list<Nucleus> NucList; // do not use std::map since we do not want unsorted list
 
  NucList nuclist;
};
 
 
class System : public LDRblock {
 
 public:
 
   System(const STD_string& object_label="unnamedSystem");
 
   System(const System& s) {System::operator = (s);}
 
  System& operator = (const System& s);
 
  odinPlatform get_platform() const;
 
  STD_string get_platform_str() const {return platformstr;}
 
  STD_string get_transmit_coil_name() const {return transmit_coil_name;}
 
  System& set_transmit_coil_name(const STD_string& tcname);
 
  STD_string get_receive_coil_name() const {return receive_coil_name;}
 
  System& set_receive_coil_name(const STD_string& rcname);
 
  STD_string get_main_nucleus() const {return main_nucleus;}
 
  System& set_main_nucleus(const STD_string& nucname);
 
  float get_max_grad() const {return max_grad;}
 
  float get_max_slew_rate() const {return max_slew_rate;}
 
  float get_grad_switch_time(float graddiff) const;
 
  float get_inter_grad_delay() const {return inter_grad_delay;}
 
  System& set_scandir(const STD_string& dir);
 
  STD_string get_scandir() const;
 
 
  float get_grad_shift_delay() const {return grad_shift;}
 
  double get_B0() const {return B0;}
 
  System& set_B0(double b0) {B0=b0; return *this;}
 
  System& set_B0_from_freq(double freq, const STD_string& nucName="");
 
  double get_gamma(const STD_string& nucName="") const;
 
  System& set_reference_gain(float refgain);
 
  float get_reference_gain() const {return reference_gain;}
 
  double get_nuc_freq(const STD_string& nucName="") const;
 
 
  LDRenum get_nuc_enum() const;
 
  double get_min_duration(objCategory c) const {return min_duration[c];}
 
  double get_min_grad_rastertime() const {return min_grad_rastertime;}
 
  double get_rastertime(objCategory cat) const;
 
  double get_rasteredtime(objCategory cat, double time) const;
 
  int get_max_rf_samples() const {return  max_rf_samples;}
 
  int get_max_grad_samples() const {return  max_grad_samples;}
 
  System& set_data_type(const STD_string& type) {datatype=type;  return *this;}
 
  STD_string get_data_type() const {return datatype;}
 
 
  bool allowed_grad_freq(double freq, double& low, double& upp) const;
 
 
 private:
  friend class SeqMethod;
  friend class SeqIdea;
  friend class SeqParavision;
  friend class SeqStandAlone;
  friend class SeqEpic;
 
  // overwriting virtual functions from LDRbase
  int load(const STD_string &filename, const LDRserBase& serializer=LDRserJDX());
 
 
 
 
  int append_all_members();
 
  Nuclei nuc;
 
  LDRstring platformstr;
  LDRenum   main_nucleus;
  LDRdouble max_grad;
  LDRdouble max_slew_rate;
  LDRdouble grad_shift;
  LDRdouble inter_grad_delay;
  LDRdouble B0;
  LDRdouble reference_gain;
  LDRstring transmit_coil_name;
  LDRstring receive_coil_name;
 
  LDRdouble delay_rastertime;
  LDRdouble rf_rastertime;
  LDRdouble grad_rastertime;
  LDRdouble min_grad_rastertime;
  LDRdouble acq_rastertime;
 
  LDRint max_rf_samples;
  LDRint max_grad_samples;
  LDRstring datatype;
 
  LDRdoubleArr grad_reson_center;
  LDRdoubleArr grad_reson_width;
 
 
  STD_string scandir;
 
  dvector min_duration;
 
};
 
 
 
class SystemInterface : public StaticHandler<SystemInterface> {
 public:
 
  SystemInterface()  {}
 
  System& operator *  () {return *get_sysinfo_ptr();}
  const System& operator * () const {return *get_const_sysinfo_ptr();}
 
  System* operator -> () {return get_sysinfo_ptr();}
  const System* operator -> () const {return get_const_sysinfo_ptr();}
 
  // functions to initialize/delete static members by the StaticHandler template class
  static void init_static();
  static void destroy_static();
 
  static void set_current_pf(odinPlatform pf);
 
  static odinPlatform get_current_pf() { // make it inline to speed up driver access
    if(current_pf) return odinPlatform(current_pf->operator int ());
//    else STD_cerr << "ERROR: SystemInterface::get_current_pf: current_pf not yet initialized" << STD_endl;
    return odinPlatform(0);
  }
 
 
 private:
//  friend class System;
  friend class SeqIdea;
  friend class SeqParavision;
  friend class SeqStandAlone;
  friend class SeqEpic;
//  friend class SeqPlatformInstances;
 
 
  static System* get_sysinfo_ptr();
  static const System* get_const_sysinfo_ptr();
 
  // the actual platform
  static SingletonHandler<LDRint,false> current_pf;
 
  // separate systemInfo for each platform
  static SingletonHandler<System,false>* systemInfo_platform;
};
 
 
 
#endif