Par04/include/Par04InferenceSetup.hh

0001 //
0002 // ********************************************************************
0003 // * License and Disclaimer                                           *
0004 // *                                                                  *
0005 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
0006 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
0007 // * conditions of the Geant4 Software License,  included in the file *
0008 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
0009 // * include a list of copyright holders.                             *
0010 // *                                                                  *
0011 // * Neither the authors of this software system, nor their employing *
0012 // * institutes,nor the agencies providing financial support for this *
0013 // * work  make  any representation or  warranty, express or implied, *
0014 // * regarding  this  software system or assume any liability for its *
0015 // * use.  Please see the license in the file  LICENSE  and URL above *
0016 // * for the full disclaimer and the limitation of liability.         *
0017 // *                                                                  *
0018 // * This  code  implementation is the result of  the  scientific and *
0019 // * technical work of the GEANT4 collaboration.                      *
0020 // * By using,  copying,  modifying or  distributing the software (or *
0021 // * any work based  on the software)  you  agree  to acknowledge its *
0022 // * use  in  resulting  scientific  publications,  and indicate your *
0023 // * acceptance of all terms of the Geant4 Software license.          *
0024 // ********************************************************************
0025 //
0026 #ifdef USE_INFERENCE
0027 #  ifndef PAR04INFEERENCESETUP_HH
0028 #    define PAR04INFEERENCESETUP_HH
0029
0030 #    include "CLHEP/Units/SystemOfUnits.h"  // for mm
0031
0032 #    include "G4ThreeVector.hh"  // for G4ThreeVector
0033
0034 #    include <G4String.hh>  // for G4String
0035 #    include <G4SystemOfUnits.hh>  // for mm
0036 #    include <G4Types.hh>  // for G4int, G4double, G4bool, G4f...
0037 #    include <memory>  // for unique_ptr
0038 #    include <vector>  // for vector
0039 class Par04DetectorConstruction;
0040 class Par04InferenceInterface;
0041 class Par04InferenceMessenger;
0042
0043 /**
0044  * @brief Inference setup.
0045  *
0046  * Constructs the input vector of size b+c to run the inference, b represents
0047  * the size of the latent space (or the encoded space in a Variational
0048  * Autoencoder based model), c represents the size of the conditional vector.
0049  *The b values of the input vector are randomly sampled from b-dimensional
0050  *Gaussian distribution. The c values represent respectively the condition
0051  *values of the particle energy, angle and detector geometry. These condition
0052  *values are user-specific application. The energy rescaling is used to retrieve
0053  *the original energy scale in MeV. Computes the cell position in the detector
0054  *of each inferred energy value.
0055  *
0056  **/
0057
0058 class Par04InferenceSetup
0059 {
0060   public:
0061     Par04InferenceSetup();
0062     ~Par04InferenceSetup();
0063
0064     /// Geometry setup
0065     /// Check if inference should be performed for the particle
0066     /// @param[in] aEnergy Particle's energy
0067     G4bool IfTrigger(G4double aEnergy);
0068     /// Set mesh size.
0069     /// @param aSize (x,y,x) size for Carthesian coordinates, or (R, phi, z) for
0070     /// cylindrical coordinates.
0071     inline void SetMeshSize(const G4ThreeVector& aSize) { fMeshSize = aSize; };
0072     /// Get mesh size.
0073     /// @return G4ThreeVector (x,y,x) size for Carthesian coordinates, or (R, phi,
0074     /// z) for cylindrical coordinates.
0075     inline G4ThreeVector GetMeshSize() const { return fMeshSize; };
0076     /// Set number of mesh cells.
0077     /// @param aSize (x,y,x) size for Carthesian coordinates, or (R, phi, z) for
0078     /// cylindrical coordinates.
0079     inline void SetMeshNumber(const G4ThreeVector& aSize) { fMeshNumber = aSize; };
0080     /// Get number of mesh cells.
0081     /// @return G4ThreeVector (x,y,x) size for Carthesian coordinates, or (R, phi,
0082     /// z) for cylindrical coordinates.
0083     inline G4ThreeVector GetMeshNumber() const { return fMeshNumber; };
0084     /// Set size of the condition vector
0085     inline void SetSizeConditionVector(G4int aNumber) { fSizeConditionVector = aNumber; };
0086     /// Get size of the condition vector
0087     inline G4int GetSizeConditionVector() const { return fSizeConditionVector; };
0088     /// Set size of the latent space vector
0089     inline void SetSizeLatentVector(G4int aNumber) { fSizeLatentVector = aNumber; };
0090     /// Get size of the latent space vector
0091     inline G4int GetSizeLatentVector() const { return fSizeLatentVector; };
0092     /// Set path and name of the model
0093     inline void SetModelPathName(G4String aName) { fModelPathName = aName; };
0094     /// Get path and name of the model
0095     inline G4String GetModelPathName() const { return fModelPathName; };
0096     /// Set profiling flag
0097     inline void SetProfileFlag(G4int aNumber) { fProfileFlag = aNumber; };
0098     /// Get profiling flag
0099     inline G4int GetProfileFlag() const { return fProfileFlag; };
0100     /// Set optimization flag
0101     inline void SetOptimizationFlag(G4int aNumber) { fOptimizationFlag = aNumber; };
0102     /// Get optimization flag
0103     inline G4int GetOptimizationFlag() const { return fOptimizationFlag; };
0104     /// Get name of the inference library
0105     inline G4String GetInferenceLibrary() const { return fInferenceLibrary; };
0106     /// Set name of the inference library and create a pointer to chosen inference
0107     /// interface
0108     void SetInferenceLibrary(G4String aName);
0109     /// Check settings of the inference library
0110     void CheckInferenceLibrary();
0111     /// Set number of Mesh cells in cylindrical coordinates (r, phi, z)
0112     inline void SetMeshNbOfCells(G4ThreeVector aNb) { fMeshNumber = aNb; };
0113     /// Set number of Mesh cells in cylindrical coordinates
0114     /// @param[in] aIndex index of cylindrical axis (0,1,2) = (r, phi, z)
0115     inline void SetMeshNbOfCells(G4int aIndex, G4double aNb) { fMeshNumber[aIndex] = aNb; };
0116     /// Get number of Mesh cells in cylindrical coordinates (r, phi, z)
0117     inline G4ThreeVector GetMeshNbOfCells() const { return fMeshNumber; };
0118     /// Set size of Mesh cells in cylindrical coordinates (r, phi, z)
0119     inline void SetMeshSizeOfCells(G4ThreeVector aNb) { fMeshSize = aNb; };
0120     /// Set size of Mesh cells in cylindrical coordinates
0121     /// @param[in] aIndex index of cylindrical axis (0,1,2) = (r, phi, z)
0122     inline void SetMeshSizeOfCells(G4int aIndex, G4double aNb) { fMeshSize[aIndex] = aNb; };
0123     /// Get size of Mesh cells in cylindrical coordinates (r, phi, z)
0124     inline G4ThreeVector GetMeshSizeOfCells() const { return fMeshSize; };
0125     /// Setting execution providers flags
0126     /// GPU
0127     inline void SetCudaFlag(G4int aNumber) { fCudaFlag = aNumber; };
0128     inline G4int GetCudaFlag() const { return fCudaFlag; };
0129     /// Setting execution providers Options
0130     /// Cuda
0131     inline void SetCudaDeviceId(G4String aNumber) { fCudaDeviceId = aNumber; };
0132     inline G4String GetCudaDeviceId() const { return fCudaDeviceId; };
0133     inline void SetCudaGpuMemLimit(G4String aNumber) { fCudaGpuMemLimit = aNumber; };
0134     inline G4String GetCudaGpuMemLimit() const { return fCudaGpuMemLimit; };
0135     inline void SetCudaArenaExtendedStrategy(G4String aNumber)
0136     {
0137       fCudaArenaExtendedStrategy = aNumber;
0138     };
0139     inline G4String GetCudaArenaExtendedStrategy() const { return fCudaArenaExtendedStrategy; };
0140     inline void SetCudaCudnnConvAlgoSearch(G4String aNumber)
0141     {
0142       fCudaCudnnConvAlgoSearch = aNumber;
0143     };
0144     inline G4String GetCudaCudnnConvAlgoSearch() const { return fCudaCudnnConvAlgoSearch; };
0145     inline void SetCudaDoCopyInDefaultStream(G4String aNumber)
0146     {
0147       fCudaDoCopyInDefaultStream = aNumber;
0148     };
0149     inline G4String GetCudaDoCopyInDefaultStream() const { return fCudaDoCopyInDefaultStream; };
0150     inline void SetCudaCudnnConvUseMaxWorkspace(G4String aNumber)
0151     {
0152       fCudaCudnnConvUseMaxWorkspace = aNumber;
0153     };
0154     inline G4String GetCudaCudnnConvUseMaxWorkspace() const
0155     {
0156       return fCudaCudnnConvUseMaxWorkspace;
0157     };
0158
0159     /// Execute inference
0160     /// @param[out] aDepositsEnergies of inferred energies deposited in the
0161     /// detector
0162     /// @param[in] aParticleEnergy Energy of initial particle
0163     void GetEnergies(std::vector<G4double>& aEnergies, G4double aParticleEnergy,
0164                      G4float aInitialAngle);
0165
0166     /// Calculate positions
0167     /// @param[out] aDepositsPositions Vector of positions corresponding to
0168     /// energies deposited in the detector
0169     /// @param[in] aParticlePosition Initial particle position which is centre of
0170     /// transverse plane of the mesh
0171     ///            and beginning of the mesh in the longitudinal direction
0172     /// @param[in] aParticleDirection Initial particle direction for the mesh
0173     /// rotation
0174     void GetPositions(std::vector<G4ThreeVector>& aDepositsPositions,
0175                       G4ThreeVector aParticlePosition, G4ThreeVector aParticleDirection);
0176
0177   private:
0178     /// Cell's size: (x,y,x) for Carthesian, and (R, phi, z) for cylindrical
0179     /// coordinates Can be changed with UI command `/example/mesh/size <x y z>/<r
0180     /// phi z> <unit>`. For cylindrical coordinates phi is ignored and calculated
0181     /// from fMeshNumber.
0182     G4ThreeVector fMeshSize = G4ThreeVector(2.325 * CLHEP::mm, 1, 3.4 * CLHEP::mm);
0183     /// Number of cells: (x,y,x) for Carthesian, and (R, phi, z) for cylindrical
0184     /// coordinates. Can be changed with UI command `/example/mesh/number <Nx Ny
0185     /// Nz>/<Nr Nphi Nz>`
0186     G4ThreeVector fMeshNumber = G4ThreeVector(18, 50, 45);
0187     /// Inference interface
0188     std::unique_ptr<Par04InferenceInterface> fInferenceInterface;
0189     /// Inference messenger
0190     Par04InferenceMessenger* fInferenceMessenger;
0191     /// Maximum particle energy value (in MeV) in the training range
0192     float fMaxEnergy = 1024000.0;
0193     /// Maximum particle angle (in degrees) in the training range
0194     float fMaxAngle = 90.0;
0195     /// Name of the inference library
0196     G4String fInferenceLibrary = "ONNX";
0197     /// Size of the latent space vector
0198     G4int fSizeLatentVector = 10;
0199     /// Size of the condition vector
0200     G4int fSizeConditionVector = 4;
0201     /// Name of the inference library
0202     G4String fModelPathName = "MLModels/Generator.onnx";
0203     /// ONNX specific
0204     /// Profiling flag
0205     G4bool fProfileFlag = false;
0206     /// Optimization flag
0207     G4bool fOptimizationFlag = false;
0208     /// Optimization file
0209     G4String fModelSavePath = "MLModels/Optimized-Generator.onnx";
0210     /// Profiling file
0211     G4String fProfilingOutputSavePath = "opt.json";
0212     /// Intra-operation number of threads
0213     G4int fIntraOpNumThreads = 1;
0214     /// Flags for execution providers
0215     /// GPU
0216     G4bool fCudaFlag = false;
0217     /// Execution Provider Options
0218     /// Cuda options
0219     G4String fCudaDeviceId = "0";
0220     G4String fCudaGpuMemLimit = "2147483648";
0221     G4String fCudaArenaExtendedStrategy = "kSameAsRequested";
0222     G4String fCudaCudnnConvAlgoSearch = "DEFAULT";
0223     G4String fCudaDoCopyInDefaultStream = "1";
0224     G4String fCudaCudnnConvUseMaxWorkspace = "1";
0225     std::vector<const char*> cuda_keys{
0226       "device_id",
0227       "gpu_mem_limit",
0228       "arena_extend_strategy",
0229       "cudnn_conv_algo_search",
0230       "do_copy_in_default_stream",
0231       "cudnn_conv_use_max_workspace",
0232     };
0233     std::vector<const char*> cuda_values{
0234       fCudaDeviceId.c_str(),
0235       fCudaGpuMemLimit.c_str(),
0236       fCudaArenaExtendedStrategy.c_str(),
0237       fCudaCudnnConvAlgoSearch.c_str(),
0238       fCudaDoCopyInDefaultStream.c_str(),
0239       fCudaCudnnConvUseMaxWorkspace.c_str(),
0240     };
0241 };
0242
0243 #  endif /* PAR04INFEERENCESETUP_HH */
0244 #endif