World.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 WORLD_H_
#define WORLD_H_
 
#include "Declarations.h"
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <fstream>
#include <vector>
#include     <map>
 
 
using namespace std;
 
//forward declarations
class AtomicSequence;
class ConcatSequence;
class SequenceTree;
class EddyPulse;
 
 
class World {
 
 public:
 
 //MODIF
        bool logFile;
 
 
        bool logTrajectories;
 
 
        void setTrajLoading(int firstSpin, int paketSize)  { m_trajBegin=firstSpin; m_trajSize=paketSize; };
 
 
        long getTrajBegin() { return m_trajBegin; };
 
        long getTrajNumber() { return m_trajSize; };
 //MODIF***
 
 
        virtual ~World   ();
 
    static World*  instance      ();
 
    double ConcomitantField (double* G);
 
        void   SetNoOfSpinProps (int n); 
 
        int    GetNoOfSpinProps () {return m_noofspinprops;};
 
 
        double*    Helper () {
                return &helper[0];
        };
 
 
        void InitHelper (long size);
 
 
        int GetNoOfCompartments ();
 
 
        void SetNoOfCompartments (int n);
 
 
    void      (*saveEvolFunPtr)(long l, bool b)  ;
 
    void*             solverSettings ;      
    bool              solverSuccess;        
        void*             auxiliary;           
        //members for solution of a particular spin
    long              SpinNumber;                   
    long              TotalSpinNumber;      
    long              TotalADCNumber;       
    double*           Values;               
    double            time;                 
    double            total_time;           
    double            phase;                
    double            PhaseLock;            
    double            deltaB;               
    std::vector<double> solution;           
    double            LargestM0;            
    double            RandNoise;            
    double            GMAXoverB0;           
    double            NonLinGradField;      
    //members for the current sequence
    SequenceTree*     pSeqTree;             
    AtomicSequence*   pAtom;                
    AtomicSequence*   pStaticAtom;          
    //members for saving the magnetization evolution of the spins
    int               saveEvolStepSize;     
    string            saveEvolFileName;     
    ofstream*         saveEvolOfstream;     
    int                           m_myRank;                             
    bool                          m_useLoadBalancing;   
    int                           m_no_processes;               
    //MODIF
    long              m_trajBegin;          
    long              m_trajSize;           
    //MODIF***
 
    long                          m_startSpin;                  
        int               m_noofspinprops;      
        int               m_noofspincompartments; 
        std::vector<double> helper;
        //double*           helper;             /** @brief Any additional data necessary for solving the model. (i.e. Global MT exchange matrix) */
        
        multimap<EddyPulse*,double>     m_eddies; 
    int                           m_slice;              
    int                           m_set;                
    int                           m_contrast;           
    int                           m_average;            
    int                           m_shot;               
    int                           m_shotmax;            
    int                           m_partition;          
    int                           m_partitionmax;       
    string            m_seqSignature;        
 private:
 
    World  () {};
 
    static World*    m_instance;           
};
 
#endif /*WORLD_H_*/