#ifndef TFieldManager_h
#define TFieldManager_h

#include "IOAMagneticField.hxx"
#include "TVector3.h"
#include <map>
#include <set>


namespace COMET {
  class IFieldManager;
};

///    \brief This singleton makes it possible to change the magnetic field within a run
///    \author Christian Hansen, hansen@ific.uv.es
///    \author Eike Frank, eike.frank@lhep.unibe.ch
///
///    IFieldManager 
///   
///    This class is a singleton. It has no constructor and all member-     
///    functions are static. It saves in memory an instant of IOAMagneticField. 
///    For now it only manages the B field (E field in future).
///   
///    A simple example how this class can be called:
/// 
///    \code
///    #include "IFieldManager.hxx"
///    ...
///    IFieldManager::InitializeFieldManager();
///    TVector3 point(1.,1.,1.);
///    TVector3 B1 = IFieldManager::GetFieldValue(point);
///    cout<<"B1 (x,y,z)  "<<B1.X()/unit::tesla<<" "<<B1.Y()/unit::tesla<<" "<<B1.Z()/unit::tesla<<endl;
///    \endcode


// structure holding a comparison operator for TVector3 in order to allow stroing data in std::map
struct classcomp {
  bool operator()(const TVector3 &lhs, const TVector3 &rhs) {
	if (lhs.z() != rhs.z())
	  return lhs.z() < rhs.z();
	if (lhs.x() != rhs.x())
	  return lhs.x() < rhs.x();
	return lhs.y() < rhs.y();  
  }
};


class COMET::IFieldManager {

 public:

  /// Get a pointer to the singleton instance of the geometry information.
  static IFieldManager& Get(void);

  ///Initialize field manager. The Magnetic Field Type will be as requested in data base unless
  ///SetMagneticFieldType (see below) is used
  static void InitializeFieldManager();
  ///Set the Magnetic Field Type
  /*!
   * Overwriting the B-Field type requested in DB
   *  - 0; A zero B-field
   *  - 1; The nominal field.  i.e.the measured point-to-point field map for data (type 9) and the MC field for MC (type 5).  
   *  - 2; Nominal field with an error (error strength can be set by SetFieldError)
   *  - 3; "Perfect" B Field. Only Bx = field strength
   *  - 4; NOMAD field map. Note that the NOMAD field
   *       map has by default 0.4T as the field strength. This can be changed by SetFieldStrength.
   *  - 5; The B Field currently used by SimG4 (will change)
   *  - 6; The SIMFIELD simulated field map 
   *  - 7; Obsolete map using polyomial fits to the mapped data.
   *  - 8; Simple homogenous field where one can set each of the B-field coordinates.
   *  - 9; A point to point field map of the measurements done in Sep 2009. This map uses a linear interpoaltion between the meaurement points.
   *  - 111; This is not a real map, it is just there for the purpose of testing the geometrical implementation of the map.
  */

  static void SetMagneticFieldType(int fieldType);
  static int GetMagneticFieldType();

  /// Set the error strength in case of field type 2
  static void SetFieldError(double err);

  /// Set the maximal field strength. Default is 0.4T for NOMAD and 0.2T for the other map types.
  static void SetFieldStrength(double bMax);

  /// Set the value of the Field 
  static void SetFieldValue(double x, double y, double z);

  /// Method to return the B field at a position (for now time does not matter, this is here just in case for future)     
  static TVector3 GetFieldValue(const TLorentzVector point);
  
  /// Method to return the B field at a position                     
  static TVector3 GetFieldValue(const TVector3 point);

  /// Method to return the B field at a position and field type                    
  static TVector3 GetFieldValue(const TVector3 point, int type);

  /// Method to return the B field at a position and field type 
  /// (for now time does not matter, this is here just in case for future)     
  static TVector3 GetFieldValue(const TLorentzVector point, int type);

  //Methods for access to dats from B-Field mapping
  void LoadMapData(void);
  std::map <TVector3, TVector3, classcomp> *GetBMap(int arm_nr);
  //void GetBMap2Arr(int arm_nr,TVector3 magarm[][41][78]);
  TVector3 *GetBMapArr(int arm_nr);


  
  //void GetBMap2Arr(int arm_nr,TVector3 magarm);
  std::set<float> *GetNodesX(int arm_nr);
  std::set<float> *GetNodesY(int arm_nr);
  std::set<float> *GetNodesZ(int arm_nr);

 

 private:
  static bool fFieldManagerIsInitialized;
  static COMET::IOAMagneticField* fMagField;

  IFieldManager();
  ~IFieldManager();


  static COMET::IOAMagneticField& GetMagneticField();

  /// The static pointer to the singleton instance.
  static IFieldManager* fTFieldManager;

  double fBFieldType;

  //pointers to the information from the B-Field mapping
 
  std::map<TVector3, TVector3, classcomp> *fPtrBMap2;
 

  // TVector3 magfieldarm2[39][41][78];
  //TVector3 magfieldarm3[11][41][78];
  TVector3 magfieldarm2[39*41*78];
  TVector3 magfieldarm3[39*41*78];

  //TVector3 (*fPtrMagArm2)[41][78];
  //TVector3 (*fPtrMagArm3)[41][78];

  std::set<float> *fPtrNodesX2;
  std::set<float> *fPtrNodesY2;
  std::set<float> *fPtrNodesZ2;
  std::map<TVector3, TVector3, classcomp> *fPtrBMap3;
  std::set<float> *fPtrNodesX3;
  std::set<float> *fPtrNodesY3;
  std::set<float> *fPtrNodesZ3;
};


namespace COMET{
  IFieldManager& Bman();
};

#endif // #ifdef TFieldManager_h