Declarations.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 DECLARATIONS_H_
#define DECLARATIONS_H_
 
#include <string>
 
// from FFTW
#define PI    3.141592653589793238462643383279502884197169399375105820974944592
#define TWOPI 6.283185307179586476925286766559005768394338798750211641949889185
const double TIME_ERR_TOL = 2.5e-6; // Avoid CVODE warnings. Doesn't affect physics.
 
//#define SLAVE_GRADS
 
//const int NO_SPIN_PROPERTIES = 10;
 
enum fields {
        XC=0,               
        YC,                 
        ZC,                 
        M0,                 
        R1,                 
        R2,                 
        R2S,                
        DB,                 
        ID,                 
        NO_SPIN_PROPERTIES  
};
 
enum cylinder {
        RC = 3,             
        RT,                 
        RZ                               
};
 
enum polar {
        AMPL,               
        PHASE               
};
 
enum seqval {
        RF_AMP,                             
        RF_PHS,                             
        GRAD_X,                             
        GRAD_Y,                             
        GRAD_Z,                             
};
 
const seqval MAX_SEQ_VAL = GRAD_Z;
 
 
enum PulseAxis {AXIS_RF, AXIS_GX, AXIS_GY, AXIS_GZ,
        AXIS_VOID
};
 
enum SensitivityMethod {
        UNIFORM,                         
        ONE_OVER_R_SQUARE,   
        BIOT_SAVART_LOOP,    
        ONE_OVER_R
};
 
enum mode {
    RX,            
    TX            
};
 
enum MpiTag {
        REQUEST_SPINS=66,
        SEND_NO_SPINS,
        SEND_TOTAL_NO_SPINS, //MODIF
        SEND_BEGIN_SPIN, //MODIF
        SEND_SAMPLE,
        SPINS_PROGRESS,
        SIG_TP,
        SIG_MX,
        SIG_MY,
        SIG_MZ
};
 
 
namespace IO {
 
        enum Strategy {
                NONE = -1,
                SIMPLE,        
                HDF5,          
                CDF,           
                IOSTRATEGIES   
        };
        
        enum Status {
                OK,                          
                EMPTY_FILE_NAME,             
                FILE_NOT_FOUND,              
                INSUFFICIENT_PRIVILEGES,     
                HDF5_FILE_I_EXCEPTION,       
                HDF5_DATASET_I_EXCEPTION,    
                HDF5_DATASPACE_I_EXCEPTION,  
                HDF5_DATATYPE_I_EXCEPTION,    
                UNMATCHED_DIMENSIONS,
                LAST_STATUS_ENTRY
        };
 
        static std::string StatusMessage[LAST_STATUS_ENTRY]  = {
                std::string("IO notice: OK."),
                std::string("IO error: Empty file name."),
                std::string("IO error: File not found."),
                std::string("IO error: Insufficient privileges."),
                std::string("IO error: HDF5, general file excption."),
                std::string("IO error: HDF5, dataset exception."),
                std::string("IO error: HDF5, dataspace exception."),
                std::string("IO error: HDF5, datatype exception.")
        };
                
        
        enum Mode {
                IN, 
                OUT, 
                APPEND 
        };
        
}
 
namespace Sim {
        
        /*enum Result {
                OK,
                NAN,
                DIVISION_BY_ZERO
                };*/
        
}
 
#include <algorithm>
 
static inline std::string strtoupper (const std::string& str) {
    std::string res = str;
    std::transform(res.begin(), res.end(), res.begin(), ::toupper);
    return res;
}
 
static inline std::string strtolower (const std::string& str) {
    std::string res = str;
    std::transform(res.begin(), res.end(), res.begin(), ::tolower);
    return res;
}
 
static inline bool strcompare (const std::string& a, const std::string& b) {
        return strtoupper(a).compare(strtoupper(b));
}
 
 
#endif /*DECLARATIONS_H_*/