ShipFieldMaker.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_SHIPFIELDMAKER_H_
#define FIELD_SHIPFIELDMAKER_H_
 
#include <map>
#include <string>
#include <vector>
 
#include "ShipCompField.h"
#include "TG4VUserPostDetConstruction.h"
#include "TString.h"
#include "TVector2.h"
#include "TVector3.h"
#include "TVirtualMagField.h"
 
class TGeoMatrix;
class TGeoNode;
class TGeoVolume;
 
class ShipFieldMaker : public TG4VUserPostDetConstruction {
 public:
  explicit ShipFieldMaker(Bool_t verbose = kFALSE);
 
  virtual ~ShipFieldMaker();
 
  typedef std::map<TString, TVirtualMagField*> SFMap;
 
  typedef std::vector<std::string> stringVect;
 
  struct fieldInfo {
    TString volName_;
    TString fieldName_;
    Double_t scale_;
 
    fieldInfo() : volName_(""), fieldName_(""), scale_(1.0) {};
 
    fieldInfo(const TString& volName, const TString& fieldName,
              Double_t scale = 1.0)
        : volName_(volName), fieldName_(fieldName), scale_(scale) {};
  };
 
  virtual void Construct();
 
 
  void readInputFile(const std::string& inputFile);
 
 
  void defineUniform(const TString& name, const TVector3& BVector);
 
 
  void defineConstant(const TString& name, const TVector2& xRange,
                      const TVector2& yRange, const TVector2& zRange,
                      const TVector3& BVector);
 
 
  void defineBell(const TString& name, Double_t BPeak, Double_t zMiddle,
                  Int_t orient = 1, Double_t tubeR = 500.0, Double_t xy = 0.0,
                  Double_t z = 0.0, Double_t L = 0.0);
 
  // ! Define a field map
  void defineFieldMap(const TString& name, const TString& mapFileName,
                      const TVector3& localCentre = TVector3(0.0, 0.0, 0.0),
                      const TVector3& localAngles = TVector3(0.0, 0.0, 0.0),
                      Bool_t useSymmetry = kFALSE);
 
 
  void defineFieldMapCopy(const TString& name, const TString& mapNameToCopy,
                          const TVector3& translation,
                          const TVector3& eulerAngles = TVector3(0.0, 0.0,
                                                                 0.0));
 
 
  void defineComposite(const TString& name, const TString& field1Name,
                       const TString& field2Name,
                       const TString& field3Name = "",
                       const TString& field4Name = "");
 
 
  void defineComposite(const TString& name, std::vector<TString> fieldNames);
 
 
  void defineGlobalField(const TString& field1Name,
                         const TString& field2Name = "",
                         const TString& field3Name = "",
                         const TString& field4Name = "");
 
 
  void defineGlobalField(std::vector<TString> fieldNames);
 
 
  void defineRegionField(const TString& volName, const TString& fieldName,
                         Double_t scale = 1.0);
 
 
  void defineLocalField(const TString& volName, const TString& fieldName,
                        Double_t scale = 1.0);
 
 
  ShipCompField* getGlobalField() const { return globalField_; }
 
 
  SFMap getAllFields() const { return theFields_; }
 
 
  TVirtualMagField* getVolumeField(const TString& volName) const;
 
 
  Bool_t gotField(const TString& name) const;
 
 
  TVirtualMagField* getField(const TString& name) const;
 
 
  void plotXYField(const TVector3& xAxis, const TVector3& yAxis,
                   const std::string& plotFile) const;
 
 
  void plotZXField(const TVector3& zAxis, const TVector3& xAxis,
                   const std::string& plotFile) const;
 
 
  void plotZYField(const TVector3& zAxis, const TVector3& yAxis,
                   const std::string& plotFile) const;
 
 
  void plotField(Int_t type, const TVector3& xAxis, const TVector3& yAxis,
                 const std::string& plotFile) const;
 
  void generateFieldMap(TString fileName, const float step = 2.5,
                        const float xRange = 179, const float yRange = 317,
                        const float zRange = 1515.5,
                        const float zShift = -4996);
 
  ClassDef(ShipFieldMaker, 1);
 
 protected:
  struct transformInfo {
    Double_t x0_;
    Double_t y0_;
    Double_t z0_;
 
    Double_t phi_;
    Double_t theta_;
    Double_t psi_;
  };
 
 
  void defineUniform(const stringVect& inputLine);
 
 
  void defineConstant(const stringVect& inputLine);
 
 
  void defineBell(const stringVect& inputLine);
 
 
  void defineFieldMap(const stringVect& inputLine, Bool_t useSymmetry = kFALSE);
 
 
  void defineFieldMapCopy(const stringVect& inputLine);
 
 
  void defineComposite(const stringVect& inputLine);
 
 
  void defineGlobalField(const stringVect& inputLine);
 
 
  void defineRegionField(const stringVect& inputLine);
 
  // ! Setup all of the regional fields. Called by Construct()
  void setAllRegionFields();
 
 
  void defineLocalField(const stringVect& inputLine);
 
 
  void checkLocalFieldMap(TVirtualMagField*& localField, const TString& volName,
                          Double_t scale);
 
  // ! Setup all of the local fields. Called by Construct()
  void setAllLocalFields();
 
 
  void getTransformation(const TString& volName, transformInfo& theInfo);
 
 
  void findNode(TGeoVolume* aVolume, const TString& volName);
 
 private:
  ShipCompField* globalField_;
 
  SFMap theFields_;
 
  std::vector<fieldInfo> regionInfo_;
 
  std::vector<fieldInfo> localInfo_;
 
  Bool_t verbose_;
 
  Double_t Tesla_;
 
  TGeoNode* theNode_;
 
  Bool_t gotNode_;
 
 
  stringVect splitString(std::string& theString, std::string& splitter) const;
};
 
#endif  // FIELD_SHIPFIELDMAKER_H_