seqmeth.h

/***************************************************************************
                          seqmeth.h  -  description
                             -------------------
    begin                : Thu Aug 9 2001
    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 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 JDXeditCaller, 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);}


  JcampDxBlock& 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(JcampDxClass& 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 JDXeditCaller
  void parameter_relations(JDXeditWidget* editwidget);

  // interface for quick access to current platform
  mutable SeqPlatformProxy platform;

  // block to hold method-specific parameters
  JcampDxBlock* 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