ShipBFieldMap.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright CERN for the benefit of the SHiP
// Collaboration
 
#ifndef FIELD_SHIPBFIELDMAP_H_
#define FIELD_SHIPBFIELDMAP_H_
 
#include <string>
#include <utility>
#include <vector>
 
#include "TGeoMatrix.h"
#include "TVirtualMagField.h"
 
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) = delete;
  ShipBFieldMap& operator=(const ShipBFieldMap& rhs) = delete;
 
  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  // FIELD_SHIPBFIELDMAP_H_