seqtree.h

/***************************************************************************
                          seqtree.h  -  description
                             -------------------
    begin                : Fri Oct 17 2003
    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 SEQTREE_H
#define SEQTREE_H
 
#include <tjutils/tjvallist.h>
 
#include <odinseq/seqclass.h>
#include <odinseq/seqoperator.h>
 
 
 
 
class SeqTreeCallbackAbstract {
 
 public:
  virtual void display_node(const SeqClass* thisnode, const SeqClass* parentnode, int treelevel, const svector& columntext) = 0;
 
};
 
 
class ProgressMeter; // forward declaration
 
enum eventAction {seqRun=0, printEvent, countEvents};
 
struct eventContext {
  eventContext() : action(seqRun), abort(false), noflush(false), seqcheck(false),
                   elapsed(0.0),
                   event_display(0), event_progmeter(0) {}
 
  // the action to be performed
  eventAction action;
 
  // signal to abort execution of the sequence
  bool abort;
 
  // do not flush eventblock
  bool noflush;
 
  // just a test run (e.g. fSEQCheck on Idea)
  bool seqcheck;
 
  // counter for time elapsed since start of the sequence
  double elapsed;
 
  // callback pointers to display events in GUI/console
  SeqTreeCallbackAbstract* event_display;
 
  // pointer for progess meter
  ProgressMeter* event_progmeter;
 
  // helper function to update/increase progmeter and store status in 'abort'
  void increase_progmeter();
 
};
 
 
enum freqlistAction {calcDeps=0,calcList,calcAcqList,calcDecList};
 
 
enum programMode {brukerPpg=0, brukerGpg, brukerParx, epicCode, epicPg, epicScan, epicPreScan, epicPreScanDummy, numOfProgModes};
 
 
struct programContext {
  programContext() : mode(programMode(0)), formatted(true), nestlevel(0), neststatus(false)  {}
 
  // the type of program to generate
  programMode mode;
 
  // whether code is nicely formatted (indention, comments), the main
  // use of this flag is to decide whether to blocks of code are the
  // same (despite formatting) and whether they can be wrapped in a loop
  bool formatted;
 
  // counter for indention if generating pulse programs
  int nestlevel;
 
  // whether indention is currently enabled
  bool neststatus;
};
 
 
 
class SeqTreeObj; //forward declaration
 
enum queryAction {count_acqs, checkoccur, check_acq_iter, tag_toplevel_reploop, display_tree};
 
struct queryContext {
  queryContext() : action(count_acqs), numof_acqs(0),
  checkoccur_sto(0), checkoccur_result(false),
  check_acq_iter_result(false),
  tree_display(0), parentnode(0), treelevel(0),
  repetitions_prot(0) {}
 
  // the action requested
  queryAction action;
 
  // stuff for action 'count_acqs'
  unsigned int numof_acqs;
 
  // stuff for action 'checkoccur'
  const SeqTreeObj* checkoccur_sto;
  bool checkoccur_result;
 
  bool check_acq_iter_result;
  
  // stuff for action 'display_tree'
  SeqTreeCallbackAbstract* tree_display;
  const SeqTreeObj* parentnode;
  int treelevel;
 
  // stuff for action 'tag_toplevel_reploop'
  int repetitions_prot; // the number of reps in the protocol
};
 
 
 
struct SeqValList : public ValList<double> {
  SeqValList(const STD_string& object_label="unnamedSeqValList", unsigned int repetitions=1) : ValList<double>(object_label,repetitions) {}
};
 
 
 
 
class SeqTreeObj : public virtual SeqClass {
 
 public:
 
  virtual double get_duration() const = 0;
 
  virtual STD_string get_program(programContext& context) const {return "";}
 
  virtual STD_string get_properties() const {return "";}
 
 
  virtual unsigned int event(eventContext& context) const { // make inline to speed up event execution
    if(context.action==printEvent) display_event(context);
    context.elapsed+=get_duration();
    return 0; // no real hardware events played out
  }
 
 
  virtual RecoValList get_recovallist(unsigned int reptimes, LDRkSpaceCoords& coords) const {return RecoValList();}
 
  bool contains(const SeqTreeObj* sto) const;
 
  void tree(SeqTreeCallbackAbstract* display) const;
 
  virtual SeqValList get_freqvallist(freqlistAction action) const {return SeqValList();}
 
  virtual SeqValList get_delayvallist() const {return SeqValList();}
 
  virtual double get_rf_energy() const {return 0.0;}
 
 
 protected:
  friend class SeqObjList;
  friend class SeqObjVector;
  friend class SeqParallel;
 
 
 
  SeqTreeObj();
 
  virtual ~SeqTreeObj() {}
 
  SeqTreeObj& operator = (const SeqTreeObj& sto) {
    SeqClass::operator =(sto);
    return *this;
  }
 
  virtual void query(queryContext& context) const;
 
 
  static int looplevel;
 
 private:
  void display_event(eventContext& context) const;
 
};
 
 
 
#endif