ShipBFieldMap.h

Go to the documentation of this file.

 
#ifndef ShipBFieldMap_H
#define ShipBFieldMap_H
 
#include "TGeoMatrix.h"
#include "TVirtualMagField.h"
 
#include <string>
#include <utility>
#include <vector>
 
class ShipBFieldMap : public TVirtualMagField
{
 
 public:
 
 
    ShipBFieldMap(const std::string& label, const std::string& mapFileName,
          Float_t xOffset = 0.0, Float_t yOffset = 0.0, Float_t zOffset = 0.0,
          Float_t phi = 0.0, Float_t theta = 0.0, Float_t psi = 0.0,
          Float_t scale = 1.0, Bool_t isSymmetric = kFALSE);
 
 
    ShipBFieldMap(const std::string& newName, const ShipBFieldMap& rhs,
          Float_t newXOffset, Float_t newYOffset, Float_t newZOffset,
          Float_t newPhi = 0.0, Float_t newTheta = 0.0, Float_t newPsi = 0.0,
          Float_t newScale = 1.0);
 
    virtual ~ShipBFieldMap();
 
 
    virtual void Field(const Double_t* position, Double_t* B);
 
    typedef std::vector< std::vector<Float_t> > floatArray;
 
 
    floatArray* getFieldMap() const {return fieldMap_;}
 
 
    void SetXOffset(Float_t xValue) {xOffset_ = xValue;}
 
 
    void SetYOffset(Float_t yValue) {yOffset_ = yValue;}
 
 
    void SetZOffset(Float_t zValue) {zOffset_ = zValue;}
 
 
    void SetPhi(Float_t phi) {phi_ = phi;}
 
 
    void SetTheta(Float_t theta) {theta_ = theta;}
 
 
    void SetPsi(Float_t psi) {psi_ = psi;}
 
 
    void SetScale(Float_t scale) {scale_ = scale;}
 
 
    void UseSymmetry(Bool_t flag) {isSymmetric_ = flag;}
 
 
 
    std::string GetMapFileName() const {return mapFileName_;}
 
 
    Int_t GetNx() const {return Nx_;}
 
 
    Int_t GetNy() const {return Ny_;}
 
 
    Int_t GetNz() const {return Nz_;}
 
 
    Int_t GetNBins() const {return N_;}
 
 
    Float_t GetXMin() const {return xMin_;}
 
 
    Float_t GetXMax() const {return xMax_;}
 
 
    Float_t GetdX() const {return dx_;}
 
 
    Float_t GetXRange() const {return xRange_;}
 
 
    Float_t GetYMin() const {return yMin_;}
 
 
    Float_t GetYMax() const {return yMax_;}
 
 
    Float_t GetdY() const {return dy_;}
 
 
    Float_t GetYRange() const {return yRange_;}
 
 
    Float_t GetZMin() const {return zMin_;}
 
 
    Float_t GetZMax() const {return zMax_;}
 
 
    Float_t GetdZ() const {return dz_;}
 
 
    Float_t GetZRange() const {return zRange_;}
 
 
    Float_t GetXOffset() const {return xOffset_;}
 
 
    Float_t GetYOffset() const {return yOffset_;}
 
 
    Float_t GetZOffset() const {return zOffset_;}
 
 
    Float_t GetPhi() const {return phi_;}
 
 
    Float_t GetTheta() const {return theta_;}
 
 
    Float_t GetPsi() const {return psi_;}
 
 
    Float_t GetScale() const {return scale_;}
 
 
    Bool_t HasSymmetry() const {return isSymmetric_;}
 
 
    Bool_t IsACopy() const {return isCopy_;}
 
    ClassDef(ShipBFieldMap,1);
 
 
 protected:
 
 private:
 
    ShipBFieldMap(const ShipBFieldMap& rhs);
 
    ShipBFieldMap& operator=(const ShipBFieldMap& rhs);
 
    enum CoordAxis {xAxis = 0, yAxis, zAxis};
 
    void initialise();
 
    void readMapFile();
 
    void readRootFile();
 
    void readTextFile();
 
    // ! Set the coordinate limits from information stored in the datafile
    void setLimits();
 
 
    Bool_t insideRange(Float_t x, Float_t y, Float_t z);
 
    typedef std::pair<Int_t, Float_t> binPair;
 
 
    binPair getBinInfo(Float_t x, CoordAxis theAxis);
 
 
    Int_t getMapBin(Int_t iX, Int_t iY, Int_t iZ);
 
 
    Float_t BInterCalc(CoordAxis theAxis);
 
    floatArray* fieldMap_;
 
    std::string mapFileName_;
 
    Bool_t initialised_;
 
    Bool_t isCopy_;
 
    Int_t Nx_;
    
    Int_t Ny_;
 
    Int_t Nz_;
 
    Int_t N_;
 
    Float_t xMin_;
 
    Float_t xMax_;
 
    Float_t dx_;
 
    Float_t xRange_;
 
    Float_t yMin_;
 
    Float_t yMax_;
 
    Float_t dy_;
 
    Float_t yRange_;
 
    Float_t zMin_;
 
    Float_t zMax_;
 
    Float_t dz_;
 
    Float_t zRange_;
 
    Float_t xOffset_;
 
    Float_t yOffset_;
 
    Float_t zOffset_;
 
    Float_t phi_;
 
    Float_t theta_;
 
    Float_t psi_;
 
    Float_t scale_;
 
    Bool_t isSymmetric_;
 
    TGeoMatrix* theTrans_;
 
    Float_t Tesla_;
 
    Int_t binA_;
 
    Int_t binB_;
 
    Int_t binC_;
 
    Int_t binD_;
 
    Int_t binE_;
 
    Int_t binF_;
 
    Int_t binG_;
 
    Int_t binH_;
 
    Float_t xFrac_;
 
    Float_t yFrac_;
 
    Float_t zFrac_;
 
    Float_t xFrac1_;
 
    Float_t yFrac1_;
 
    Float_t zFrac1_;
 
};
 
#endif