seqmeth.h

/***************************************************************************
                          seqmeth.h  -  description
                             -------------------
    begin                : Thu Aug 9 2001
    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 SEQMETH_H
#define SEQMETH_H
 
#include <tjutils/tjstate.h>
#include <tjutils/tjhandler.h>
 
#include <odinpara/protocol.h>
 
#include <odinseq/seqlist.h>
#include <odinseq/seqplatform.h>
 
 
 
// forward declarations
class SeqMethod;
class SeqPulsar;
 
 
 
 
class SeqMethodProxy : public StaticHandler<SeqMethodProxy> {
 
 
 public:
  SeqMethodProxy() {
    Log<Seq> odinlog("SeqMethodProxy","SeqMethodProxy()");
  }
 
  static void set_current_method(unsigned int index);
  static SeqMethod* get_current_method();
  static unsigned int get_numof_methods();
  static unsigned int delete_methods();
  static const char* get_method_label();
 
  static const char* get_status_string();
 
  // pointer-like syntax to access current method
  SeqMethod* operator -> () {return get_current_method();}
  SeqMethod& operator [] (unsigned int index);
 
  static bool load_method_so(const STD_string& so_filename);
 
  // functions to initialize/delete static members by the StaticHandler template class
  static void init_static();
  static void destroy_static();
 
 
 protected:
 
  // called by derivedmethod classes to register themselves
  static void register_method(SeqMethod* meth);
 
 
 private:
 
  // struct to store references to all registered methods
  struct MethodList : public STD_list<SeqMethod*>, public Labeled {};
 
  static SingletonHandler<MethodList,false> registered_methods;
 
  
  // struct to store references to the current method
  struct MethodPtr : public Labeled {
    SeqMethod* ptr;
  };
 
  static SingletonHandler<MethodPtr,false> current_method;
 
  static SeqMethod* empty_method;
 
 
};
 
 
 
 
/*
  State diagram for SeqMethod, i.e. for all NMR sequences:
 
  Possible transitions between states are indicated by
  the corresponding member functions that perform the transition.
 
 
  empty <--------\
                 |
    |            | clear()
    | init()     |
    |            |
    V            |
                 |
  initialised ---|
                 |
    |            |
    | build()    |
    |            |
    V            |
                 |
  built ---------|
                 |
    |            |
    | prepare()  |
    |            |
    V            |
                 |
  prepared ------'
 
*/
 
 
 
 
class SeqMethod : protected SeqMethodProxy, public SeqObjList, public virtual LDReditCaller, public StateMachine<SeqMethod> {
 
 
 public:
 
  SeqMethod(const STD_string& method_label);
 
  virtual ~SeqMethod();
 
  // public interface to obtain the different states:
 
  bool clear() {return empty.obtain_state();}
 
  bool init() {return initialised.obtain_state();}
 
  bool build() {return built.obtain_state();}
 
  bool prepare() {return prepared.obtain_state();}
 
  bool update_timings();
 
  bool prep_acquisition() const;
 
 
  const char* get_description() const {return description.c_str();}
 
  int process(int argc, char *argv[]);
 
 
  int load_protocol(const STD_string& filename);
 
  int write_protocol(const STD_string& filename) const {create_protcache(); return protcache->write(filename);}
 
 
  LDRblock& get_methodPars() {return *methodPars;}
 
  int load_sequencePars(const STD_string& filename);
 
  int write_sequencePars(const STD_string& filename) const;
 
  bool set_sequenceParameter(const STD_string& parameter_label, const STD_string& value);
 
  SeqMethod& set_commonPars(const SeqPars& pars);
 
  SeqPars& get_commonPars() {return (*commonPars);}
 
  SeqMethod& set_geometry(const Geometry& geo)  {geometryInfo->operator = (geo); return *this;}
 
  Geometry& get_geometry() {return *(geometryInfo.unlocked_ptr());}
 
  int load_geometry(const STD_string& filename) {return geometryInfo->load(filename);}
 
  int write_geometry(const STD_string& filename) const {return geometryInfo->write(filename);}
 
  Study& get_studyInfo() {return *(studyInfo.unlocked_ptr());}
 
  int write_systemInfo(const STD_string& filename) const {return systemInfo->write(filename);}
 
  int load_systemInfo(const STD_string& filename);
 
  SeqMethod& init_systemInfo(double basicfreq,double maxgrad,double slewrate);
 
  int write_recoInfo(const STD_string& filename) const;
 
  int write_meas_contex(const STD_string& prefix) const;
 
  double get_totalDuration() const;
 
  STD_string get_main_nucleus() const {return systemInfo->get_main_nucleus();}
 
  unsigned int get_numof_acquisitions() const;
 
  STD_list<const SeqPulsar*>  get_active_pulsar_pulses() const;
  
  // overloaded virtual functions from SeqTreeObj
  unsigned int event(eventContext& context) const;
 
  // leave this public for idea_emulation
  void set_current_testcase(unsigned int index) {if(index<numof_testcases()) current_testcase=index;}
 
 
 protected:
 
  virtual void method_pars_init() = 0;
 
  virtual void method_seq_init() = 0;
 
  virtual void method_rels() = 0;
 
  virtual void method_pars_set() = 0;
 
 
  SeqMethod& append_parameter(LDRbase& ldr,const STD_string& label,parameterMode parmode=edit);
 
  SeqMethod& set_sequence(const SeqObjBase& s);
 
 
  SeqMethod& set_description(const char* descr) {description=descr;return *this;}
 
 
  virtual unsigned int numof_testcases() const {return 1;}
 
  unsigned int get_current_testcase() const {return current_testcase;}
 
 
  SeqPars* commonPars;
 
 private:
  friend class SeqMethodProxy;
  friend class SeqCmdLine;
 
  void set_parblock_labels();
 
  bool calc_timings();
 
 
  // overloaded virtual function from LDReditCaller
  void parameter_relations(LDReditWidget* editwidget);
 
  // interface for quick access to current platform
  mutable SeqPlatformProxy platform;
 
  // block to hold method-specific parameters
  LDRblock* methodPars;
 
  STD_string description;
 
  unsigned int current_testcase;
 
 
  // cache handle to method plug-in so that it can be removed later
  void *dl_handle;
 
 
  void create_protcache() const;
  mutable Protocol* protcache; // used for returning reference to protocol, local static object does not work on VxWorks
 
 
 
  // states and their transition functions:
 
  State<SeqMethod> empty;
  bool reset();
 
  State<SeqMethod> initialised;
  bool empty2initialised();
 
  State<SeqMethod> built;
  bool initialised2built();
 
  State<SeqMethod> prepared;
  bool built2prepared();
};
 
 
// Macro to include in every sequence file to create an entry point
 
// Double-stage macros to stringize METHOD_LABEL, see http://c-faq.com/ansi/stringize.html
#define ODINMETHOD_STRINGIZE_MACRO(x) #x
#define ODINMETHOD_STRINGIZE(x) ODINMETHOD_STRINGIZE_MACRO(x)
 
 
#ifdef NO_CMDLINE
 
#define ODINMETHOD_ENTRY_POINT \
int ODINMAIN(int argc, char *argv[]) {\
  return (new METHOD_CLASS(ODINMETHOD_STRINGIZE(METHOD_LABEL)))->process(argc,argv); \
}
 
#else
 
#define ODINMETHOD_ENTRY_POINT \
int ODINMAIN(int argc, char *argv[]) {\
  if(LogBase::set_log_levels(argc,argv,false)) return 0; \
  return (new METHOD_CLASS(ODINMETHOD_STRINGIZE(METHOD_LABEL)))->process(argc,argv); \
}
 
#endif
 
 
#endif