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 model type
0097     inline void SetModelType(G4String aName) { fModelType = aName; };
0098     /// Get model type
0099     inline G4String GetModelType() const { return fModelType; };
0100     /// Set profiling flag
0101     inline void SetProfileFlag(G4int aNumber) { fProfileFlag = aNumber; };
0102     /// Get profiling flag
0103     inline G4int GetProfileFlag() const { return fProfileFlag; };
0104     /// Set optimization flag
0105     inline void SetOptimizationFlag(G4int aNumber) { fOptimizationFlag = aNumber; };
0106     /// Get optimization flag
0107     inline G4int GetOptimizationFlag() const { return fOptimizationFlag; };
0108     /// Get name of the inference library
0109     inline G4String GetInferenceLibrary() const { return fInferenceLibrary; };
0110     /// Set name of the inference library and create a pointer to chosen inference
0111     /// interface
0112     void SetInferenceLibrary(G4String aName);
0113     /// Check settings of the inference library
0114     void CheckInferenceLibrary();
0115     /// Set number of Mesh cells in cylindrical coordinates (r, phi, z)
0116     inline void SetMeshNbOfCells(G4ThreeVector aNb) { fMeshNumber = aNb; };
0117     /// Set number of Mesh cells in cylindrical coordinates
0118     /// @param[in] aIndex index of cylindrical axis (0,1,2) = (r, phi, z)
0119     inline void SetMeshNbOfCells(G4int aIndex, G4double aNb) { fMeshNumber[aIndex] = aNb; };
0120     /// Get number of Mesh cells in cylindrical coordinates (r, phi, z)
0121     inline G4ThreeVector GetMeshNbOfCells() const { return fMeshNumber; };
0122     /// Set size of Mesh cells in cylindrical coordinates (r, phi, z)
0123     inline void SetMeshSizeOfCells(G4ThreeVector aNb) { fMeshSize = aNb; };
0124     /// Set size of Mesh cells in cylindrical coordinates
0125     /// @param[in] aIndex index of cylindrical axis (0,1,2) = (r, phi, z)
0126     inline void SetMeshSizeOfCells(G4int aIndex, G4double aNb) { fMeshSize[aIndex] = aNb; };
0127     /// Get size of Mesh cells in cylindrical coordinates (r, phi, z)
0128     inline G4ThreeVector GetMeshSizeOfCells() const { return fMeshSize; };
0129     /// Setting execution providers flags
0130     /// GPU
0131     inline void SetCudaFlag(G4int aNumber) { fCudaFlag = aNumber; };
0132     inline G4int GetCudaFlag() const { return fCudaFlag; };
0133     /// Setting execution providers Options
0134     /// Cuda
0135     inline void SetCudaDeviceId(G4String aNumber) { fCudaDeviceId = aNumber; };
0136     inline G4String GetCudaDeviceId() const { return fCudaDeviceId; };
0137     inline void SetCudaGpuMemLimit(G4String aNumber) { fCudaGpuMemLimit = aNumber; };
0138     inline G4String GetCudaGpuMemLimit() const { return fCudaGpuMemLimit; };
0139     inline void SetCudaArenaExtendedStrategy(G4String aNumber)
0140     {
0141       fCudaArenaExtendedStrategy = aNumber;
0142     };
0143     inline G4String GetCudaArenaExtendedStrategy() const { return fCudaArenaExtendedStrategy; };
0144     inline void SetCudaCudnnConvAlgoSearch(G4String aNumber)
0145     {
0146       fCudaCudnnConvAlgoSearch = aNumber;
0147     };
0148     inline G4String GetCudaCudnnConvAlgoSearch() const { return fCudaCudnnConvAlgoSearch; };
0149     inline void SetCudaDoCopyInDefaultStream(G4String aNumber)
0150     {
0151       fCudaDoCopyInDefaultStream = aNumber;
0152     };
0153     inline G4String GetCudaDoCopyInDefaultStream() const { return fCudaDoCopyInDefaultStream; };
0154     inline void SetCudaCudnnConvUseMaxWorkspace(G4String aNumber)
0155     {
0156       fCudaCudnnConvUseMaxWorkspace = aNumber;
0157     };
0158     inline G4String GetCudaCudnnConvUseMaxWorkspace() const
0159     {
0160       return fCudaCudnnConvUseMaxWorkspace;
0161     };
0162
0163     /// Execute inference
0164     /// @param[out] aDepositsEnergies of inferred energies deposited in the
0165     /// detector
0166     /// @param[in] aParticleEnergy Energy of initial particle
0167     void GetEnergies(std::vector<G4double>& aEnergies, G4double aParticleEnergy,
0168                    G4float aTheta, G4float aPhi);
0169
0170     /// Calculate positions
0171     /// @param[out] aDepositsPositions Vector of positions corresponding to
0172     /// energies deposited in the detector
0173     /// @param[in] aParticlePosition Initial particle position which is centre of
0174     /// transverse plane of the mesh
0175     ///            and beginning of the mesh in the longitudinal direction
0176     /// @param[in] aParticleDirection Initial particle direction for the mesh
0177     /// rotation
0178     void GetPositions(std::vector<G4ThreeVector>& aDepositsPositions,
0179                       G4ThreeVector aParticlePosition, G4ThreeVector aParticleDirection);
0180
0181   private:
0182     /// Cell's size: (x,y,x) for Carthesian, and (R, phi, z) for cylindrical
0183     /// coordinates Can be changed with UI command `/example/mesh/size <x y z>/<r
0184     /// phi z> <unit>`. For cylindrical coordinates phi is ignored and calculated
0185     /// from fMeshNumber.
0186     G4ThreeVector fMeshSize = G4ThreeVector(2.325 * CLHEP::mm, 1, 3.4 * CLHEP::mm);
0187     /// Number of cells: (x,y,x) for Carthesian, and (R, phi, z) for cylindrical
0188     /// coordinates. Can be changed with UI command `/example/mesh/number <Nx Ny
0189     /// Nz>/<Nr Nphi Nz>`
0190     G4ThreeVector fMeshNumber = G4ThreeVector(18, 50, 45);
0191     /// Inference interface
0192     std::unique_ptr<Par04InferenceInterface> fInferenceInterface;
0193     /// Inference messenger
0194     Par04InferenceMessenger* fInferenceMessenger;
0195     /// Maximum particle energy value (in MeV) in the training range
0196     float fMaxEnergy = 1024000.0;
0197     /// Maximum particle angle (in degrees) in the training range
0198     float fMaxAngle = 90.0;
0199     /// Name of the inference library
0200     G4String fInferenceLibrary = "ONNX";
0201     /// Size of the latent space vector
0202     G4int fSizeLatentVector = 10;
0203     /// Size of the condition vector
0204     G4int fSizeConditionVector = 4;
0205     /// Name of the inference library
0206     G4String fModelPathName = "MLModels/Generator.onnx";
0207     /// Model type
0208     G4String fModelType = "VAE";
0209     /// ONNX specific
0210     /// Profiling flag
0211     G4bool fProfileFlag = false;
0212     /// Optimization flag
0213     G4bool fOptimizationFlag = false;
0214     /// Optimization file
0215     G4String fModelSavePath = "MLModels/Optimized-Generator.onnx";
0216     /// Profiling file
0217     G4String fProfilingOutputSavePath = "opt.json";
0218     /// Intra-operation number of threads
0219     G4int fIntraOpNumThreads = 1;
0220     /// Flags for execution providers
0221     /// GPU
0222     G4bool fCudaFlag = false;
0223     /// Execution Provider Options
0224     /// Cuda options
0225     G4String fCudaDeviceId = "0";
0226     G4String fCudaGpuMemLimit = "2147483648";
0227     G4String fCudaArenaExtendedStrategy = "kSameAsRequested";
0228     G4String fCudaCudnnConvAlgoSearch = "DEFAULT";
0229     G4String fCudaDoCopyInDefaultStream = "1";
0230     G4String fCudaCudnnConvUseMaxWorkspace = "1";
0231     std::vector<const char*> cuda_keys{
0232       "device_id",
0233       "gpu_mem_limit",
0234       "arena_extend_strategy",
0235       "cudnn_conv_algo_search",
0236       "do_copy_in_default_stream",
0237       "cudnn_conv_use_max_workspace",
0238     };
0239     std::vector<const char*> cuda_values{
0240       fCudaDeviceId.c_str(),
0241       fCudaGpuMemLimit.c_str(),
0242       fCudaArenaExtendedStrategy.c_str(),
0243       fCudaCudnnConvAlgoSearch.c_str(),
0244       fCudaDoCopyInDefaultStream.c_str(),
0245       fCudaCudnnConvUseMaxWorkspace.c_str(),
0246     };
0247 };
0248
0249 #  endif /* PAR04INFEERENCESETUP_HH */
0250 #endif