BDSUtilities.hh

/* 
Beam Delivery Simulation (BDSIM) Copyright (C) Royal Holloway, 
University of London 2001 - 2024.
 
This file is part of BDSIM.
 
BDSIM 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 version 3 of the License.
 
BDSIM 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 BDSIM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BDSUTILITIES_H
#define BDSUTILITIES_H
 
#include "globals.hh"   // geant4 globals / types
#include "G4String.hh"
#include "G4ThreeVector.hh"
#include "G4TwoVector.hh"
 
#include <limits>
#include <map>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
class BDSExtent;
 
class G4UserLimits;
 
namespace CLHEP {
  class HepRotation;
}
typedef CLHEP::HepRotation G4RotationMatrix;
 
namespace BDS
{
  struct non_alpha
  {
    G4bool operator()(char c);
  };
 
  G4bool StrContains(const G4String& str, const G4String& test);
 
  G4int StrCompare(const G4String& str, const G4String&, G4String::caseCompare mode=G4String::ignoreCase);
 
  G4String LowerCase(const G4String& str);
 
  enum class StringStripType
  {
    leading,
    trailing,
    both
  };
  G4String StrStrip(const G4String& str,
                    char ch,
                    StringStripType stripType = StringStripType::both);
 
  G4String PrepareSafeName(G4String name);
 
  G4int CalculateOrientation(G4double angle);
 
  std::pair<G4ThreeVector,G4ThreeVector> CalculateFaces(G4double angleInIn,
                                                        G4double angleOutIn);
 
  void EnsureInLimits(G4double& value, G4double lowerLimit, G4double upperLimit);
 
  G4bool FileExists(const G4String& filename);
 
  G4bool DirectoryExists(const G4String& path);
 
  std::string GetCurrentDir();
  
  std::string GetBDSIMExecPath();
 
  G4String GetFullPath(G4String filename, bool excludeNameFromPath=false, bool useCWDForPrefix=false);
 
  void SplitPathAndFileName(const G4String& filePath,
                            G4String& path,
                            G4String& filename);
 
  void SplitFileAndExtension(const G4String& fileName,
                             G4String&       file,
                             G4String&       extension);
 
  void HandleAborts(int signal_number);
  
  G4bool IsFinite(G4double value,
                  G4double tolerance = std::numeric_limits<double>::epsilon());
 
  G4bool IsFinite(const G4ThreeVector& variable,
                  G4double tolerance = std::numeric_limits<double>::epsilon());
 
  G4bool NonZero(G4double value);
 
  G4bool IsFiniteStrength(G4double variable);
 
  G4bool IsInteger(const char* s, int& convertedInteger);
  
  G4bool IsNumber(const char* s, double& convertedNumber);
 
  template <typename T>
  G4int Sign(T val)
  {return G4int((T(0) < val) - (val < T(0)));}
 
  inline G4String BoolToString(G4bool in)
  {return in ? "true" : "false";}
  
  void PrintRotationMatrix(G4RotationMatrix* rm, G4String keyName = "unknown");
 
  G4bool Geant4EnvironmentIsSet();
 
  void CheckHighPrecisionDataExists(const G4String& physicsListName);
 
  void CheckLowEnergyNeutronDataExists(const G4String& phhysicsListName);
    
  G4double GetParameterValueDouble(G4String spec, G4String name);
  G4String GetParameterValueString(G4String spec, G4String name);
  G4int    GetParameterValueInt(G4String spec, G4String name);
 
  std::vector<G4String> SplitOnWhiteSpace(const G4String& input);
  
  G4TwoVector Rotate(const G4TwoVector& vec, const G4double& angle);
 
  G4bool WillIntersect(const G4ThreeVector& incomingNormal,
                       const G4ThreeVector& outgoingNormal,
                       const G4double&      zSeparation,
                       const BDSExtent&     incomingExtent,
                       const BDSExtent&     outgoingExtent);
 
  G4bool WillIntersect(const G4double& angleIn,
                       const G4double& angleOut,
                       const G4double& horizontalWidth,
                       const G4double& length);
 
  G4double GetZOfPointOnPlane(const G4ThreeVector& normal, G4double x, G4double y);
 
  G4ThreeVector RotateToReferenceFrame(G4ThreeVector faceNormal, G4double fullAngle);
 
  std::pair<G4String, G4String> SplitOnColon(const G4String& formatAndPath);
 
  G4UserLimits* CreateUserLimits(G4UserLimits*  defaultUL,
                                 G4double length,
                                 G4double fraction = 1.6);
 
  G4double GetMemoryUsage();
 
  std::map<G4String, G4String> GetUserParametersMap(const G4String& userParameters,
                                                    char delimiter = ':');
 
  template <typename K, typename V>
  V MapGetWithDefault(const std::map <K,V>& m, const K& key, const V& defaultValue)
  {
    typename std::map<K,V>::const_iterator it = m.find(key);
    return it == m.end() ? defaultValue : it->second;
  }
  template <typename K, typename V>
  V MapGetWithDefault(const std::unordered_map <K,V>& m, const K& key, const V& defaultValue)
  {
    typename std::unordered_map<K,V>::const_iterator it = m.find(key);
    return it == m.end() ? defaultValue : it->second;
  }
 
  G4int VerboseEventStop(G4int verboseEventStart,
                         G4int verboseEventContinueFor);
 
  G4bool VerboseThisEvent(G4int eventIndex,
                          G4int eventStart,
                          G4int eventStop);
 
  G4double Rigidity(G4double momentumMagnitude,
                    G4double charge);
 
  inline G4bool StartsWith(const std::string& expression,
                           const std::string& prefix) {return expression.size() >= prefix.size() &&
      expression.rfind(prefix, 0) == 0;}
 
  inline G4bool EndsWith(const std::string& expression,
                         const std::string& suffix) {return expression.size() >= suffix.size() &&
      expression.compare(expression.size() - suffix.size(), suffix.size(), suffix) == 0;}
 
  G4double CalculateSafeAngledVolumeLength(G4double angleIn,
                                           G4double angleOut,
                                           G4double length,
                                           G4double containerWidth,
                                           G4double containerHeight=0);
 
  G4double CalculateSafeAngledVolumeLength(G4ThreeVector inputfaceIn,
                                           G4ThreeVector outputfaceIn,
                                           G4double length,
                                           G4double containerWidth,
                                           G4double containerHeight=0);
 
  G4double ArcLengthFromChordLength(G4double chordLength, G4double angle);
}
 
#endif