Simulator.h

Go to the documentation of this file.

 
/*
 *  JEMRIS Copyright (C) 
 *                        2006-2025  Tony Stoecker
 *                        2007-2018  Kaveh Vahedipour
 *                        2009-2019  Daniel Pflugfelder
 *                                  
 *
 *  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.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef SIMULATOR_H_
#define SIMULATOR_H_
 
#include "ConcatSequence.h"
#include "XMLIO.h"
#include "World.h"
#include "Sample.h"
#include "CoilArray.h"
#include "Bloch_CV_Model.h"
#include "KSpace.h"
 
class Simulator {
 
 
 public:
 
        Simulator        (
                        const std::string& fname,
                        const std::string& fsample   = "",
                        const std::string& frxarray  = "",
                        const std::string& ftxarray  = "",
                        const std::string& fsequence = "",
                        const std::string& fmodel    = "");
 
 
        virtual ~Simulator       ();
 
        bool GetStatus           () const { return m_state; }
 
        int         GetEvolution () const { return m_evol;  }
 
        string      GetAttr      (DOMElement* element, const string& key);
 
        string      GetAtts      (DOMElement* element, string* keys);
 
        DOMElement* GetElem      (string name);
 
        void        Simulate     (bool bDumpSignal = true);
 
        void      SetSample      (std::string fsample);
 
        void      SetSample      (Sample* sample);
 
        Sample*          GetSample      () { return    m_sample;      };
 
        Model*           GetModel       () { return    m_model;       };
 
        ConcatSequence*  GetSequence    () { return    m_sequence;    };
 
        CoilArray*       GetTxCoilArray () { return    m_tx_coil_array; };
 
        CoilArray*       GetRxCoilArray () { return    m_rx_coil_array; };
 
        void      SetSequence    (string seq="");
 
        void     CheckRestart();
 
        void     DeleteTmpFiles();
 
 //protected:
 
        Simulator ();
 
        void      SetWorld       ();
 
        void      SetRxCoilArray (string frxarray="");
 
        void      SetTxCoilArray (string ftxarray="");
 
        void      SetModel       (string fmodel="");
 
        void      SetParameter   ();
 
        void      SetOutputDir(string output_dir);
 
        void      SetSignalPrefix(string prefix);
 
 private:
 
        void     MoveTmpFiles();
 
        bool                     m_state;             
        int                      m_evol;              
        DOMDocument*             m_dom_doc;           
        Sample*                  m_sample;            
        World*                   m_world;             
        Model*                   m_model;                         
        ConcatSequence*          m_sequence;          
        SequenceTree*            m_seqtree;           
        XMLIO*                   m_xio;               
        CoilArray*               m_tx_coil_array;     
        CoilArray*               m_rx_coil_array;     
        DOMTreeErrorReporter*    m_domtree_error_rep; 
        KSpace<double,4>*        m_kspace;            
        string                   m_output_dir;        
        string                   m_signal_prefix;     
};
 
#endif /*SIMULATOR_H_*/