system.h

/***************************************************************************
                          system.h  -  description
                             -------------------
    begin                : Wed Jun 29 2005
    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 SYSTEM_H
#define SYSTEM_H

#include <tjutils/tjhandler.h>

#include <odinpara/jdxblock.h>
#include <odinpara/jdxnumbers.h>
#include <odinpara/jdxarrays.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;


  JDXenum 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 JcampDxBlock {

 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_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_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;


  JDXenum 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 JcampDxClass
  int load(const STD_string &filename);




  int append_all_members();

  Nuclei nuc;

  JDXstring platformstr;
  JDXenum   main_nucleus;
  JDXdouble max_grad;
  JDXdouble max_slew_rate;
  JDXdouble grad_shift;
  JDXdouble inter_grad_delay;
  JDXdouble B0;
  JDXdouble reference_gain;
  JDXstring transmit_coil_name;

  JDXdouble delay_rastertime;
  JDXdouble rf_rastertime;
  JDXdouble grad_rastertime;
  JDXdouble min_grad_rastertime;
  JDXdouble acq_rastertime;

  JDXint max_rf_samples;
  JDXint max_grad_samples;
  JDXstring datatype;

  JDXdoubleArr grad_reson_center;
  JDXdoubleArr 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<JDXint,false> current_pf;

  // separate systemInfo for each platform
  static SingletonHandler<System,false>* systemInfo_platform;
};



#endif

---