xsuite 0.40.0__cp312-cp312-macosx_11_0_arm64.whl → 0.40.2__cp312-cp312-macosx_11_0_arm64.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of xsuite might be problematic. Click here for more details.
- xsuite/lib/default_base_config.c +46493 -46493
- xsuite/lib/default_base_config.cpython-312-darwin.so +0 -0
- xsuite/lib/default_base_config.json +2 -2
- xsuite/lib/default_no_config.c +47296 -47296
- xsuite/lib/default_no_config.cpython-312-darwin.so +0 -0
- xsuite/lib/default_no_config.json +2 -2
- xsuite/lib/non_tracking_kernels.c +226 -226
- xsuite/lib/non_tracking_kernels.cpython-312-darwin.so +0 -0
- xsuite/lib/non_tracking_kernels.json +2 -2
- xsuite/lib/only_xtrack_with_synrad.c +18666 -18666
- xsuite/lib/only_xtrack_with_synrad.cpython-312-darwin.so +0 -0
- xsuite/lib/only_xtrack_with_synrad.json +2 -2
- {xsuite-0.40.0.dist-info → xsuite-0.40.2.dist-info}/METADATA +4 -4
- xsuite-0.40.2.dist-info/RECORD +23 -0
- xsuite-0.40.0.dist-info/RECORD +0 -23
- {xsuite-0.40.0.dist-info → xsuite-0.40.2.dist-info}/WHEEL +0 -0
- {xsuite-0.40.0.dist-info → xsuite-0.40.2.dist-info}/entry_points.txt +0 -0
- {xsuite-0.40.0.dist-info → xsuite-0.40.2.dist-info}/licenses/LICENSE +0 -0
- {xsuite-0.40.0.dist-info → xsuite-0.40.2.dist-info}/top_level.txt +0 -0
|
@@ -77,6 +77,34 @@
|
|
|
77
77
|
|
|
78
78
|
#endif // XSTUITE_TRACK_FLAGS_H
|
|
79
79
|
|
|
80
|
+
#ifndef XOBJ_TYPEDEF_ArrNFloat64
|
|
81
|
+
#define XOBJ_TYPEDEF_ArrNFloat64
|
|
82
|
+
typedef struct ArrNFloat64_s * ArrNFloat64;
|
|
83
|
+
static inline ArrNFloat64 ArrNFloat64_getp(ArrNFloat64 restrict obj){
|
|
84
|
+
int64_t offset=0;
|
|
85
|
+
return (ArrNFloat64)(( char*) obj+offset);
|
|
86
|
+
}
|
|
87
|
+
static inline int64_t ArrNFloat64_len(ArrNFloat64 restrict obj){
|
|
88
|
+
int64_t offset=0;
|
|
89
|
+
int64_t* arr = ( int64_t*)(( char*) obj+offset);
|
|
90
|
+
return arr[1];
|
|
91
|
+
}
|
|
92
|
+
static inline double ArrNFloat64_get(const ArrNFloat64 restrict obj, int64_t i0){
|
|
93
|
+
int64_t offset=0;
|
|
94
|
+
offset+=16+i0*8;
|
|
95
|
+
return *( double*)(( char*) obj+offset);
|
|
96
|
+
}
|
|
97
|
+
static inline void ArrNFloat64_set(ArrNFloat64 restrict obj, int64_t i0, double value){
|
|
98
|
+
int64_t offset=0;
|
|
99
|
+
offset+=16+i0*8;
|
|
100
|
+
*( double*)(( char*) obj+offset)=value;
|
|
101
|
+
}
|
|
102
|
+
static inline double* ArrNFloat64_getp1(ArrNFloat64 restrict obj, int64_t i0){
|
|
103
|
+
int64_t offset=0;
|
|
104
|
+
offset+=16+i0*8;
|
|
105
|
+
return ( double*)(( char*) obj+offset);
|
|
106
|
+
}
|
|
107
|
+
#endif
|
|
80
108
|
#ifndef XOBJ_TYPEDEF_ArrNInt64
|
|
81
109
|
#define XOBJ_TYPEDEF_ArrNInt64
|
|
82
110
|
typedef struct ArrNInt64_s * ArrNInt64;
|
|
@@ -105,32 +133,22 @@ typedef struct ArrNInt64_s * ArrNInt64;
|
|
|
105
133
|
return ( int64_t*)(( char*) obj+offset);
|
|
106
134
|
}
|
|
107
135
|
#endif
|
|
108
|
-
#ifndef
|
|
109
|
-
#define
|
|
110
|
-
typedef struct
|
|
111
|
-
static inline
|
|
136
|
+
#ifndef XOBJ_TYPEDEF_ArrNString
|
|
137
|
+
#define XOBJ_TYPEDEF_ArrNString
|
|
138
|
+
typedef struct ArrNString_s * ArrNString;
|
|
139
|
+
static inline ArrNString ArrNString_getp(ArrNString restrict obj){
|
|
112
140
|
int64_t offset=0;
|
|
113
|
-
return (
|
|
141
|
+
return (ArrNString)(( char*) obj+offset);
|
|
114
142
|
}
|
|
115
|
-
static inline int64_t
|
|
143
|
+
static inline int64_t ArrNString_len(ArrNString restrict obj){
|
|
116
144
|
int64_t offset=0;
|
|
117
145
|
int64_t* arr = ( int64_t*)(( char*) obj+offset);
|
|
118
146
|
return arr[1];
|
|
119
147
|
}
|
|
120
|
-
static inline
|
|
121
|
-
int64_t offset=0;
|
|
122
|
-
offset+=16+i0*8;
|
|
123
|
-
return *( double*)(( char*) obj+offset);
|
|
124
|
-
}
|
|
125
|
-
static inline void ArrNFloat64_set(ArrNFloat64 restrict obj, int64_t i0, double value){
|
|
126
|
-
int64_t offset=0;
|
|
127
|
-
offset+=16+i0*8;
|
|
128
|
-
*( double*)(( char*) obj+offset)=value;
|
|
129
|
-
}
|
|
130
|
-
static inline double* ArrNFloat64_getp1(ArrNFloat64 restrict obj, int64_t i0){
|
|
148
|
+
static inline char* ArrNString_getp1(ArrNString restrict obj, int64_t i0){
|
|
131
149
|
int64_t offset=0;
|
|
132
|
-
offset
|
|
133
|
-
return (
|
|
150
|
+
offset=*( int64_t*)(( char*) obj+offset+16+i0*8);
|
|
151
|
+
return ( char*)(( char*) obj+offset);
|
|
134
152
|
}
|
|
135
153
|
#endif
|
|
136
154
|
#ifndef XOBJ_TYPEDEF_ArrNUint32
|
|
@@ -161,24 +179,6 @@ typedef struct ArrNUint32_s * ArrNUint32;
|
|
|
161
179
|
return ( uint32_t*)(( char*) obj+offset);
|
|
162
180
|
}
|
|
163
181
|
#endif
|
|
164
|
-
#ifndef XOBJ_TYPEDEF_ArrNString
|
|
165
|
-
#define XOBJ_TYPEDEF_ArrNString
|
|
166
|
-
typedef struct ArrNString_s * ArrNString;
|
|
167
|
-
static inline ArrNString ArrNString_getp(ArrNString restrict obj){
|
|
168
|
-
int64_t offset=0;
|
|
169
|
-
return (ArrNString)(( char*) obj+offset);
|
|
170
|
-
}
|
|
171
|
-
static inline int64_t ArrNString_len(ArrNString restrict obj){
|
|
172
|
-
int64_t offset=0;
|
|
173
|
-
int64_t* arr = ( int64_t*)(( char*) obj+offset);
|
|
174
|
-
return arr[1];
|
|
175
|
-
}
|
|
176
|
-
static inline char* ArrNString_getp1(ArrNString restrict obj, int64_t i0){
|
|
177
|
-
int64_t offset=0;
|
|
178
|
-
offset=*( int64_t*)(( char*) obj+offset+16+i0*8);
|
|
179
|
-
return ( char*)(( char*) obj+offset);
|
|
180
|
-
}
|
|
181
|
-
#endif
|
|
182
182
|
#ifndef XOBJ_TYPEDEF_MultiSetterData
|
|
183
183
|
#define XOBJ_TYPEDEF_MultiSetterData
|
|
184
184
|
typedef struct MultiSetterData_s * MultiSetterData;
|
|
@@ -5755,156 +5755,156 @@ if (_sin_rot_s > -2.) {
|
|
|
5755
5755
|
// #endif //only_for_context cpu_openmp
|
|
5756
5756
|
}
|
|
5757
5757
|
|
|
5758
|
-
#ifndef
|
|
5759
|
-
#define
|
|
5760
|
-
typedef struct
|
|
5761
|
-
static inline
|
|
5758
|
+
#ifndef XOBJ_TYPEDEF_RandomExponentialData
|
|
5759
|
+
#define XOBJ_TYPEDEF_RandomExponentialData
|
|
5760
|
+
typedef struct RandomExponentialData_s * RandomExponentialData;
|
|
5761
|
+
static inline RandomExponentialData RandomExponentialData_getp(RandomExponentialData restrict obj){
|
|
5762
5762
|
int64_t offset=0;
|
|
5763
|
-
return (
|
|
5763
|
+
return (RandomExponentialData)(( char*) obj+offset);
|
|
5764
5764
|
}
|
|
5765
|
-
static inline uint8_t
|
|
5765
|
+
static inline uint8_t RandomExponentialData_get__dummy(const RandomExponentialData restrict obj){
|
|
5766
5766
|
int64_t offset=0;
|
|
5767
5767
|
return *(( uint8_t*) obj+offset);
|
|
5768
5768
|
}
|
|
5769
|
-
static inline void
|
|
5769
|
+
static inline void RandomExponentialData_set__dummy(RandomExponentialData restrict obj, uint8_t value){
|
|
5770
5770
|
int64_t offset=0;
|
|
5771
5771
|
*(( uint8_t*) obj+offset)=value;
|
|
5772
5772
|
}
|
|
5773
|
-
static inline uint8_t*
|
|
5773
|
+
static inline uint8_t* RandomExponentialData_getp__dummy(RandomExponentialData restrict obj){
|
|
5774
5774
|
int64_t offset=0;
|
|
5775
5775
|
return ( uint8_t*)(( char*) obj+offset);
|
|
5776
5776
|
}
|
|
5777
|
-
static inline double
|
|
5777
|
+
static inline double RandomExponentialData_get__sin_rot_s(const RandomExponentialData restrict obj){
|
|
5778
5778
|
int64_t offset=0;
|
|
5779
5779
|
offset+=8;
|
|
5780
5780
|
return *( double*)(( char*) obj+offset);
|
|
5781
5781
|
}
|
|
5782
|
-
static inline void
|
|
5782
|
+
static inline void RandomExponentialData_set__sin_rot_s(RandomExponentialData restrict obj, double value){
|
|
5783
5783
|
int64_t offset=0;
|
|
5784
5784
|
offset+=8;
|
|
5785
5785
|
*( double*)(( char*) obj+offset)=value;
|
|
5786
5786
|
}
|
|
5787
|
-
static inline double*
|
|
5787
|
+
static inline double* RandomExponentialData_getp__sin_rot_s(RandomExponentialData restrict obj){
|
|
5788
5788
|
int64_t offset=0;
|
|
5789
5789
|
offset+=8;
|
|
5790
5790
|
return ( double*)(( char*) obj+offset);
|
|
5791
5791
|
}
|
|
5792
|
-
static inline double
|
|
5792
|
+
static inline double RandomExponentialData_get__cos_rot_s(const RandomExponentialData restrict obj){
|
|
5793
5793
|
int64_t offset=0;
|
|
5794
5794
|
offset+=16;
|
|
5795
5795
|
return *( double*)(( char*) obj+offset);
|
|
5796
5796
|
}
|
|
5797
|
-
static inline void
|
|
5797
|
+
static inline void RandomExponentialData_set__cos_rot_s(RandomExponentialData restrict obj, double value){
|
|
5798
5798
|
int64_t offset=0;
|
|
5799
5799
|
offset+=16;
|
|
5800
5800
|
*( double*)(( char*) obj+offset)=value;
|
|
5801
5801
|
}
|
|
5802
|
-
static inline double*
|
|
5802
|
+
static inline double* RandomExponentialData_getp__cos_rot_s(RandomExponentialData restrict obj){
|
|
5803
5803
|
int64_t offset=0;
|
|
5804
5804
|
offset+=16;
|
|
5805
5805
|
return ( double*)(( char*) obj+offset);
|
|
5806
5806
|
}
|
|
5807
|
-
static inline double
|
|
5807
|
+
static inline double RandomExponentialData_get__shift_x(const RandomExponentialData restrict obj){
|
|
5808
5808
|
int64_t offset=0;
|
|
5809
5809
|
offset+=24;
|
|
5810
5810
|
return *( double*)(( char*) obj+offset);
|
|
5811
5811
|
}
|
|
5812
|
-
static inline void
|
|
5812
|
+
static inline void RandomExponentialData_set__shift_x(RandomExponentialData restrict obj, double value){
|
|
5813
5813
|
int64_t offset=0;
|
|
5814
5814
|
offset+=24;
|
|
5815
5815
|
*( double*)(( char*) obj+offset)=value;
|
|
5816
5816
|
}
|
|
5817
|
-
static inline double*
|
|
5817
|
+
static inline double* RandomExponentialData_getp__shift_x(RandomExponentialData restrict obj){
|
|
5818
5818
|
int64_t offset=0;
|
|
5819
5819
|
offset+=24;
|
|
5820
5820
|
return ( double*)(( char*) obj+offset);
|
|
5821
5821
|
}
|
|
5822
|
-
static inline double
|
|
5822
|
+
static inline double RandomExponentialData_get__shift_y(const RandomExponentialData restrict obj){
|
|
5823
5823
|
int64_t offset=0;
|
|
5824
5824
|
offset+=32;
|
|
5825
5825
|
return *( double*)(( char*) obj+offset);
|
|
5826
5826
|
}
|
|
5827
|
-
static inline void
|
|
5827
|
+
static inline void RandomExponentialData_set__shift_y(RandomExponentialData restrict obj, double value){
|
|
5828
5828
|
int64_t offset=0;
|
|
5829
5829
|
offset+=32;
|
|
5830
5830
|
*( double*)(( char*) obj+offset)=value;
|
|
5831
5831
|
}
|
|
5832
|
-
static inline double*
|
|
5832
|
+
static inline double* RandomExponentialData_getp__shift_y(RandomExponentialData restrict obj){
|
|
5833
5833
|
int64_t offset=0;
|
|
5834
5834
|
offset+=32;
|
|
5835
5835
|
return ( double*)(( char*) obj+offset);
|
|
5836
5836
|
}
|
|
5837
|
-
static inline double
|
|
5837
|
+
static inline double RandomExponentialData_get__shift_s(const RandomExponentialData restrict obj){
|
|
5838
5838
|
int64_t offset=0;
|
|
5839
5839
|
offset+=40;
|
|
5840
5840
|
return *( double*)(( char*) obj+offset);
|
|
5841
5841
|
}
|
|
5842
|
-
static inline void
|
|
5842
|
+
static inline void RandomExponentialData_set__shift_s(RandomExponentialData restrict obj, double value){
|
|
5843
5843
|
int64_t offset=0;
|
|
5844
5844
|
offset+=40;
|
|
5845
5845
|
*( double*)(( char*) obj+offset)=value;
|
|
5846
5846
|
}
|
|
5847
|
-
static inline double*
|
|
5847
|
+
static inline double* RandomExponentialData_getp__shift_s(RandomExponentialData restrict obj){
|
|
5848
5848
|
int64_t offset=0;
|
|
5849
5849
|
offset+=40;
|
|
5850
5850
|
return ( double*)(( char*) obj+offset);
|
|
5851
5851
|
}
|
|
5852
|
-
static inline double
|
|
5852
|
+
static inline double RandomExponentialData_get__rot_x_rad(const RandomExponentialData restrict obj){
|
|
5853
5853
|
int64_t offset=0;
|
|
5854
5854
|
offset+=48;
|
|
5855
5855
|
return *( double*)(( char*) obj+offset);
|
|
5856
5856
|
}
|
|
5857
|
-
static inline void
|
|
5857
|
+
static inline void RandomExponentialData_set__rot_x_rad(RandomExponentialData restrict obj, double value){
|
|
5858
5858
|
int64_t offset=0;
|
|
5859
5859
|
offset+=48;
|
|
5860
5860
|
*( double*)(( char*) obj+offset)=value;
|
|
5861
5861
|
}
|
|
5862
|
-
static inline double*
|
|
5862
|
+
static inline double* RandomExponentialData_getp__rot_x_rad(RandomExponentialData restrict obj){
|
|
5863
5863
|
int64_t offset=0;
|
|
5864
5864
|
offset+=48;
|
|
5865
5865
|
return ( double*)(( char*) obj+offset);
|
|
5866
5866
|
}
|
|
5867
|
-
static inline double
|
|
5867
|
+
static inline double RandomExponentialData_get__rot_y_rad(const RandomExponentialData restrict obj){
|
|
5868
5868
|
int64_t offset=0;
|
|
5869
5869
|
offset+=56;
|
|
5870
5870
|
return *( double*)(( char*) obj+offset);
|
|
5871
5871
|
}
|
|
5872
|
-
static inline void
|
|
5872
|
+
static inline void RandomExponentialData_set__rot_y_rad(RandomExponentialData restrict obj, double value){
|
|
5873
5873
|
int64_t offset=0;
|
|
5874
5874
|
offset+=56;
|
|
5875
5875
|
*( double*)(( char*) obj+offset)=value;
|
|
5876
5876
|
}
|
|
5877
|
-
static inline double*
|
|
5877
|
+
static inline double* RandomExponentialData_getp__rot_y_rad(RandomExponentialData restrict obj){
|
|
5878
5878
|
int64_t offset=0;
|
|
5879
5879
|
offset+=56;
|
|
5880
5880
|
return ( double*)(( char*) obj+offset);
|
|
5881
5881
|
}
|
|
5882
|
-
static inline double
|
|
5882
|
+
static inline double RandomExponentialData_get__rot_s_rad_no_frame(const RandomExponentialData restrict obj){
|
|
5883
5883
|
int64_t offset=0;
|
|
5884
5884
|
offset+=64;
|
|
5885
5885
|
return *( double*)(( char*) obj+offset);
|
|
5886
5886
|
}
|
|
5887
|
-
static inline void
|
|
5887
|
+
static inline void RandomExponentialData_set__rot_s_rad_no_frame(RandomExponentialData restrict obj, double value){
|
|
5888
5888
|
int64_t offset=0;
|
|
5889
5889
|
offset+=64;
|
|
5890
5890
|
*( double*)(( char*) obj+offset)=value;
|
|
5891
5891
|
}
|
|
5892
|
-
static inline double*
|
|
5892
|
+
static inline double* RandomExponentialData_getp__rot_s_rad_no_frame(RandomExponentialData restrict obj){
|
|
5893
5893
|
int64_t offset=0;
|
|
5894
5894
|
offset+=64;
|
|
5895
5895
|
return ( double*)(( char*) obj+offset);
|
|
5896
5896
|
}
|
|
5897
|
-
static inline double
|
|
5897
|
+
static inline double RandomExponentialData_get_rot_shift_anchor(const RandomExponentialData restrict obj){
|
|
5898
5898
|
int64_t offset=0;
|
|
5899
5899
|
offset+=72;
|
|
5900
5900
|
return *( double*)(( char*) obj+offset);
|
|
5901
5901
|
}
|
|
5902
|
-
static inline void
|
|
5902
|
+
static inline void RandomExponentialData_set_rot_shift_anchor(RandomExponentialData restrict obj, double value){
|
|
5903
5903
|
int64_t offset=0;
|
|
5904
5904
|
offset+=72;
|
|
5905
5905
|
*( double*)(( char*) obj+offset)=value;
|
|
5906
5906
|
}
|
|
5907
|
-
static inline double*
|
|
5907
|
+
static inline double* RandomExponentialData_getp_rot_shift_anchor(RandomExponentialData restrict obj){
|
|
5908
5908
|
int64_t offset=0;
|
|
5909
5909
|
offset+=72;
|
|
5910
5910
|
return ( double*)(( char*) obj+offset);
|
|
@@ -6119,11 +6119,11 @@ void Drift_single_particle(LocalParticle* part, double length){
|
|
|
6119
6119
|
|
|
6120
6120
|
#endif // XSTUITE_TRACK_FLAGS_H
|
|
6121
6121
|
|
|
6122
|
-
#include <random/random_src/
|
|
6122
|
+
#include <random/random_src/exponential.h>
|
|
6123
6123
|
|
|
6124
6124
|
|
|
6125
|
-
void
|
|
6126
|
-
|
|
6125
|
+
void sample_exp(
|
|
6126
|
+
RandomExponentialData el,
|
|
6127
6127
|
|
|
6128
6128
|
ParticlesData particles,
|
|
6129
6129
|
double* samples, int64_t n_samples_per_seed,
|
|
@@ -6171,7 +6171,7 @@ void Drift_single_particle(LocalParticle* part, double length){
|
|
|
6171
6171
|
if (part_id<part_capacity){
|
|
6172
6172
|
Particles_to_LocalParticle(particles, &lpart, part_id, end_id);
|
|
6173
6173
|
if (check_is_active(&lpart)>0){
|
|
6174
|
-
|
|
6174
|
+
RandomExponential_sample(el, &lpart, samples, n_samples_per_seed);
|
|
6175
6175
|
|
|
6176
6176
|
}
|
|
6177
6177
|
if (check_is_active(&lpart)>0 && flag_increment_at_element){
|
|
@@ -6190,159 +6190,219 @@ void Drift_single_particle(LocalParticle* part, double length){
|
|
|
6190
6190
|
// #endif //only_for_context cpu_openmp
|
|
6191
6191
|
}
|
|
6192
6192
|
|
|
6193
|
-
#ifndef
|
|
6194
|
-
#define
|
|
6195
|
-
typedef struct
|
|
6196
|
-
static inline
|
|
6193
|
+
#ifndef XOBJ_TYPEDEF_RandomRutherfordData
|
|
6194
|
+
#define XOBJ_TYPEDEF_RandomRutherfordData
|
|
6195
|
+
typedef struct RandomRutherfordData_s * RandomRutherfordData;
|
|
6196
|
+
static inline RandomRutherfordData RandomRutherfordData_getp(RandomRutherfordData restrict obj){
|
|
6197
6197
|
int64_t offset=0;
|
|
6198
|
-
return (
|
|
6198
|
+
return (RandomRutherfordData)(( char*) obj+offset);
|
|
6199
6199
|
}
|
|
6200
|
-
static inline
|
|
6200
|
+
static inline double RandomRutherfordData_get_lower_val(const RandomRutherfordData restrict obj){
|
|
6201
6201
|
int64_t offset=0;
|
|
6202
|
-
return *((
|
|
6202
|
+
return *( double*)(( char*) obj+offset);
|
|
6203
6203
|
}
|
|
6204
|
-
static inline void
|
|
6204
|
+
static inline void RandomRutherfordData_set_lower_val(RandomRutherfordData restrict obj, double value){
|
|
6205
6205
|
int64_t offset=0;
|
|
6206
|
-
*((
|
|
6206
|
+
*( double*)(( char*) obj+offset)=value;
|
|
6207
6207
|
}
|
|
6208
|
-
static inline
|
|
6208
|
+
static inline double* RandomRutherfordData_getp_lower_val(RandomRutherfordData restrict obj){
|
|
6209
6209
|
int64_t offset=0;
|
|
6210
|
-
return (
|
|
6210
|
+
return ( double*)(( char*) obj+offset);
|
|
6211
6211
|
}
|
|
6212
|
-
static inline double
|
|
6212
|
+
static inline double RandomRutherfordData_get_upper_val(const RandomRutherfordData restrict obj){
|
|
6213
6213
|
int64_t offset=0;
|
|
6214
6214
|
offset+=8;
|
|
6215
6215
|
return *( double*)(( char*) obj+offset);
|
|
6216
6216
|
}
|
|
6217
|
-
static inline void
|
|
6217
|
+
static inline void RandomRutherfordData_set_upper_val(RandomRutherfordData restrict obj, double value){
|
|
6218
6218
|
int64_t offset=0;
|
|
6219
6219
|
offset+=8;
|
|
6220
6220
|
*( double*)(( char*) obj+offset)=value;
|
|
6221
6221
|
}
|
|
6222
|
-
static inline double*
|
|
6222
|
+
static inline double* RandomRutherfordData_getp_upper_val(RandomRutherfordData restrict obj){
|
|
6223
6223
|
int64_t offset=0;
|
|
6224
6224
|
offset+=8;
|
|
6225
6225
|
return ( double*)(( char*) obj+offset);
|
|
6226
6226
|
}
|
|
6227
|
-
static inline double
|
|
6227
|
+
static inline double RandomRutherfordData_get_A(const RandomRutherfordData restrict obj){
|
|
6228
6228
|
int64_t offset=0;
|
|
6229
6229
|
offset+=16;
|
|
6230
6230
|
return *( double*)(( char*) obj+offset);
|
|
6231
6231
|
}
|
|
6232
|
-
static inline void
|
|
6232
|
+
static inline void RandomRutherfordData_set_A(RandomRutherfordData restrict obj, double value){
|
|
6233
6233
|
int64_t offset=0;
|
|
6234
6234
|
offset+=16;
|
|
6235
6235
|
*( double*)(( char*) obj+offset)=value;
|
|
6236
6236
|
}
|
|
6237
|
-
static inline double*
|
|
6237
|
+
static inline double* RandomRutherfordData_getp_A(RandomRutherfordData restrict obj){
|
|
6238
6238
|
int64_t offset=0;
|
|
6239
6239
|
offset+=16;
|
|
6240
6240
|
return ( double*)(( char*) obj+offset);
|
|
6241
6241
|
}
|
|
6242
|
-
static inline double
|
|
6242
|
+
static inline double RandomRutherfordData_get_B(const RandomRutherfordData restrict obj){
|
|
6243
6243
|
int64_t offset=0;
|
|
6244
6244
|
offset+=24;
|
|
6245
6245
|
return *( double*)(( char*) obj+offset);
|
|
6246
6246
|
}
|
|
6247
|
-
static inline void
|
|
6247
|
+
static inline void RandomRutherfordData_set_B(RandomRutherfordData restrict obj, double value){
|
|
6248
6248
|
int64_t offset=0;
|
|
6249
6249
|
offset+=24;
|
|
6250
6250
|
*( double*)(( char*) obj+offset)=value;
|
|
6251
6251
|
}
|
|
6252
|
-
static inline double*
|
|
6252
|
+
static inline double* RandomRutherfordData_getp_B(RandomRutherfordData restrict obj){
|
|
6253
6253
|
int64_t offset=0;
|
|
6254
6254
|
offset+=24;
|
|
6255
6255
|
return ( double*)(( char*) obj+offset);
|
|
6256
6256
|
}
|
|
6257
|
-
static inline
|
|
6257
|
+
static inline int8_t RandomRutherfordData_get_Newton_iterations(const RandomRutherfordData restrict obj){
|
|
6258
6258
|
int64_t offset=0;
|
|
6259
6259
|
offset+=32;
|
|
6260
|
-
return *(
|
|
6260
|
+
return *(( int8_t*) obj+offset);
|
|
6261
6261
|
}
|
|
6262
|
-
static inline void
|
|
6262
|
+
static inline void RandomRutherfordData_set_Newton_iterations(RandomRutherfordData restrict obj, int8_t value){
|
|
6263
6263
|
int64_t offset=0;
|
|
6264
6264
|
offset+=32;
|
|
6265
|
-
*(
|
|
6265
|
+
*(( int8_t*) obj+offset)=value;
|
|
6266
6266
|
}
|
|
6267
|
-
static inline
|
|
6267
|
+
static inline int8_t* RandomRutherfordData_getp_Newton_iterations(RandomRutherfordData restrict obj){
|
|
6268
6268
|
int64_t offset=0;
|
|
6269
6269
|
offset+=32;
|
|
6270
|
-
return (
|
|
6270
|
+
return ( int8_t*)(( char*) obj+offset);
|
|
6271
6271
|
}
|
|
6272
|
-
static inline double
|
|
6272
|
+
static inline double RandomRutherfordData_get__sin_rot_s(const RandomRutherfordData restrict obj){
|
|
6273
6273
|
int64_t offset=0;
|
|
6274
6274
|
offset+=40;
|
|
6275
6275
|
return *( double*)(( char*) obj+offset);
|
|
6276
6276
|
}
|
|
6277
|
-
static inline void
|
|
6277
|
+
static inline void RandomRutherfordData_set__sin_rot_s(RandomRutherfordData restrict obj, double value){
|
|
6278
6278
|
int64_t offset=0;
|
|
6279
6279
|
offset+=40;
|
|
6280
6280
|
*( double*)(( char*) obj+offset)=value;
|
|
6281
6281
|
}
|
|
6282
|
-
static inline double*
|
|
6282
|
+
static inline double* RandomRutherfordData_getp__sin_rot_s(RandomRutherfordData restrict obj){
|
|
6283
6283
|
int64_t offset=0;
|
|
6284
6284
|
offset+=40;
|
|
6285
6285
|
return ( double*)(( char*) obj+offset);
|
|
6286
6286
|
}
|
|
6287
|
-
static inline double
|
|
6287
|
+
static inline double RandomRutherfordData_get__cos_rot_s(const RandomRutherfordData restrict obj){
|
|
6288
6288
|
int64_t offset=0;
|
|
6289
6289
|
offset+=48;
|
|
6290
6290
|
return *( double*)(( char*) obj+offset);
|
|
6291
6291
|
}
|
|
6292
|
-
static inline void
|
|
6292
|
+
static inline void RandomRutherfordData_set__cos_rot_s(RandomRutherfordData restrict obj, double value){
|
|
6293
6293
|
int64_t offset=0;
|
|
6294
6294
|
offset+=48;
|
|
6295
6295
|
*( double*)(( char*) obj+offset)=value;
|
|
6296
6296
|
}
|
|
6297
|
-
static inline double*
|
|
6297
|
+
static inline double* RandomRutherfordData_getp__cos_rot_s(RandomRutherfordData restrict obj){
|
|
6298
6298
|
int64_t offset=0;
|
|
6299
6299
|
offset+=48;
|
|
6300
6300
|
return ( double*)(( char*) obj+offset);
|
|
6301
6301
|
}
|
|
6302
|
-
static inline double
|
|
6302
|
+
static inline double RandomRutherfordData_get__shift_x(const RandomRutherfordData restrict obj){
|
|
6303
6303
|
int64_t offset=0;
|
|
6304
6304
|
offset+=56;
|
|
6305
6305
|
return *( double*)(( char*) obj+offset);
|
|
6306
6306
|
}
|
|
6307
|
-
static inline void
|
|
6307
|
+
static inline void RandomRutherfordData_set__shift_x(RandomRutherfordData restrict obj, double value){
|
|
6308
6308
|
int64_t offset=0;
|
|
6309
6309
|
offset+=56;
|
|
6310
6310
|
*( double*)(( char*) obj+offset)=value;
|
|
6311
6311
|
}
|
|
6312
|
-
static inline double*
|
|
6312
|
+
static inline double* RandomRutherfordData_getp__shift_x(RandomRutherfordData restrict obj){
|
|
6313
6313
|
int64_t offset=0;
|
|
6314
6314
|
offset+=56;
|
|
6315
6315
|
return ( double*)(( char*) obj+offset);
|
|
6316
6316
|
}
|
|
6317
|
-
static inline double
|
|
6317
|
+
static inline double RandomRutherfordData_get__shift_y(const RandomRutherfordData restrict obj){
|
|
6318
6318
|
int64_t offset=0;
|
|
6319
6319
|
offset+=64;
|
|
6320
6320
|
return *( double*)(( char*) obj+offset);
|
|
6321
6321
|
}
|
|
6322
|
-
static inline void
|
|
6322
|
+
static inline void RandomRutherfordData_set__shift_y(RandomRutherfordData restrict obj, double value){
|
|
6323
6323
|
int64_t offset=0;
|
|
6324
6324
|
offset+=64;
|
|
6325
6325
|
*( double*)(( char*) obj+offset)=value;
|
|
6326
6326
|
}
|
|
6327
|
-
static inline double*
|
|
6327
|
+
static inline double* RandomRutherfordData_getp__shift_y(RandomRutherfordData restrict obj){
|
|
6328
6328
|
int64_t offset=0;
|
|
6329
6329
|
offset+=64;
|
|
6330
6330
|
return ( double*)(( char*) obj+offset);
|
|
6331
6331
|
}
|
|
6332
|
-
static inline double
|
|
6332
|
+
static inline double RandomRutherfordData_get__shift_s(const RandomRutherfordData restrict obj){
|
|
6333
6333
|
int64_t offset=0;
|
|
6334
6334
|
offset+=72;
|
|
6335
6335
|
return *( double*)(( char*) obj+offset);
|
|
6336
6336
|
}
|
|
6337
|
-
static inline void
|
|
6337
|
+
static inline void RandomRutherfordData_set__shift_s(RandomRutherfordData restrict obj, double value){
|
|
6338
6338
|
int64_t offset=0;
|
|
6339
6339
|
offset+=72;
|
|
6340
6340
|
*( double*)(( char*) obj+offset)=value;
|
|
6341
6341
|
}
|
|
6342
|
-
static inline double*
|
|
6342
|
+
static inline double* RandomRutherfordData_getp__shift_s(RandomRutherfordData restrict obj){
|
|
6343
6343
|
int64_t offset=0;
|
|
6344
6344
|
offset+=72;
|
|
6345
6345
|
return ( double*)(( char*) obj+offset);
|
|
6346
|
+
}
|
|
6347
|
+
static inline double RandomRutherfordData_get__rot_x_rad(const RandomRutherfordData restrict obj){
|
|
6348
|
+
int64_t offset=0;
|
|
6349
|
+
offset+=80;
|
|
6350
|
+
return *( double*)(( char*) obj+offset);
|
|
6351
|
+
}
|
|
6352
|
+
static inline void RandomRutherfordData_set__rot_x_rad(RandomRutherfordData restrict obj, double value){
|
|
6353
|
+
int64_t offset=0;
|
|
6354
|
+
offset+=80;
|
|
6355
|
+
*( double*)(( char*) obj+offset)=value;
|
|
6356
|
+
}
|
|
6357
|
+
static inline double* RandomRutherfordData_getp__rot_x_rad(RandomRutherfordData restrict obj){
|
|
6358
|
+
int64_t offset=0;
|
|
6359
|
+
offset+=80;
|
|
6360
|
+
return ( double*)(( char*) obj+offset);
|
|
6361
|
+
}
|
|
6362
|
+
static inline double RandomRutherfordData_get__rot_y_rad(const RandomRutherfordData restrict obj){
|
|
6363
|
+
int64_t offset=0;
|
|
6364
|
+
offset+=88;
|
|
6365
|
+
return *( double*)(( char*) obj+offset);
|
|
6366
|
+
}
|
|
6367
|
+
static inline void RandomRutherfordData_set__rot_y_rad(RandomRutherfordData restrict obj, double value){
|
|
6368
|
+
int64_t offset=0;
|
|
6369
|
+
offset+=88;
|
|
6370
|
+
*( double*)(( char*) obj+offset)=value;
|
|
6371
|
+
}
|
|
6372
|
+
static inline double* RandomRutherfordData_getp__rot_y_rad(RandomRutherfordData restrict obj){
|
|
6373
|
+
int64_t offset=0;
|
|
6374
|
+
offset+=88;
|
|
6375
|
+
return ( double*)(( char*) obj+offset);
|
|
6376
|
+
}
|
|
6377
|
+
static inline double RandomRutherfordData_get__rot_s_rad_no_frame(const RandomRutherfordData restrict obj){
|
|
6378
|
+
int64_t offset=0;
|
|
6379
|
+
offset+=96;
|
|
6380
|
+
return *( double*)(( char*) obj+offset);
|
|
6381
|
+
}
|
|
6382
|
+
static inline void RandomRutherfordData_set__rot_s_rad_no_frame(RandomRutherfordData restrict obj, double value){
|
|
6383
|
+
int64_t offset=0;
|
|
6384
|
+
offset+=96;
|
|
6385
|
+
*( double*)(( char*) obj+offset)=value;
|
|
6386
|
+
}
|
|
6387
|
+
static inline double* RandomRutherfordData_getp__rot_s_rad_no_frame(RandomRutherfordData restrict obj){
|
|
6388
|
+
int64_t offset=0;
|
|
6389
|
+
offset+=96;
|
|
6390
|
+
return ( double*)(( char*) obj+offset);
|
|
6391
|
+
}
|
|
6392
|
+
static inline double RandomRutherfordData_get_rot_shift_anchor(const RandomRutherfordData restrict obj){
|
|
6393
|
+
int64_t offset=0;
|
|
6394
|
+
offset+=104;
|
|
6395
|
+
return *( double*)(( char*) obj+offset);
|
|
6396
|
+
}
|
|
6397
|
+
static inline void RandomRutherfordData_set_rot_shift_anchor(RandomRutherfordData restrict obj, double value){
|
|
6398
|
+
int64_t offset=0;
|
|
6399
|
+
offset+=104;
|
|
6400
|
+
*( double*)(( char*) obj+offset)=value;
|
|
6401
|
+
}
|
|
6402
|
+
static inline double* RandomRutherfordData_getp_rot_shift_anchor(RandomRutherfordData restrict obj){
|
|
6403
|
+
int64_t offset=0;
|
|
6404
|
+
offset+=104;
|
|
6405
|
+
return ( double*)(( char*) obj+offset);
|
|
6346
6406
|
}
|
|
6347
6407
|
#endif
|
|
6348
6408
|
// copyright ############################### //
|
|
@@ -6554,11 +6614,11 @@ void Drift_single_particle(LocalParticle* part, double length){
|
|
|
6554
6614
|
|
|
6555
6615
|
#endif // XSTUITE_TRACK_FLAGS_H
|
|
6556
6616
|
|
|
6557
|
-
#include <random/random_src/
|
|
6617
|
+
#include <random/random_src/rutherford.h>
|
|
6558
6618
|
|
|
6559
6619
|
|
|
6560
|
-
void
|
|
6561
|
-
|
|
6620
|
+
void sample_ruth(
|
|
6621
|
+
RandomRutherfordData el,
|
|
6562
6622
|
|
|
6563
6623
|
ParticlesData particles,
|
|
6564
6624
|
double* samples, int64_t n_samples_per_seed,
|
|
@@ -6606,7 +6666,7 @@ void Drift_single_particle(LocalParticle* part, double length){
|
|
|
6606
6666
|
if (part_id<part_capacity){
|
|
6607
6667
|
Particles_to_LocalParticle(particles, &lpart, part_id, end_id);
|
|
6608
6668
|
if (check_is_active(&lpart)>0){
|
|
6609
|
-
|
|
6669
|
+
RandomRutherford_sample(el, &lpart, samples, n_samples_per_seed);
|
|
6610
6670
|
|
|
6611
6671
|
}
|
|
6612
6672
|
if (check_is_active(&lpart)>0 && flag_increment_at_element){
|
|
@@ -6625,219 +6685,159 @@ void Drift_single_particle(LocalParticle* part, double length){
|
|
|
6625
6685
|
// #endif //only_for_context cpu_openmp
|
|
6626
6686
|
}
|
|
6627
6687
|
|
|
6628
|
-
#ifndef
|
|
6629
|
-
#define
|
|
6630
|
-
typedef struct
|
|
6631
|
-
static inline
|
|
6688
|
+
#ifndef XOBJ_TYPEDEF_RandomNormalData
|
|
6689
|
+
#define XOBJ_TYPEDEF_RandomNormalData
|
|
6690
|
+
typedef struct RandomNormalData_s * RandomNormalData;
|
|
6691
|
+
static inline RandomNormalData RandomNormalData_getp(RandomNormalData restrict obj){
|
|
6632
6692
|
int64_t offset=0;
|
|
6633
|
-
return (
|
|
6693
|
+
return (RandomNormalData)(( char*) obj+offset);
|
|
6634
6694
|
}
|
|
6635
|
-
static inline
|
|
6695
|
+
static inline uint8_t RandomNormalData_get__dummy(const RandomNormalData restrict obj){
|
|
6636
6696
|
int64_t offset=0;
|
|
6637
|
-
return *(
|
|
6697
|
+
return *(( uint8_t*) obj+offset);
|
|
6638
6698
|
}
|
|
6639
|
-
static inline void
|
|
6699
|
+
static inline void RandomNormalData_set__dummy(RandomNormalData restrict obj, uint8_t value){
|
|
6640
6700
|
int64_t offset=0;
|
|
6641
|
-
*(
|
|
6701
|
+
*(( uint8_t*) obj+offset)=value;
|
|
6642
6702
|
}
|
|
6643
|
-
static inline
|
|
6703
|
+
static inline uint8_t* RandomNormalData_getp__dummy(RandomNormalData restrict obj){
|
|
6644
6704
|
int64_t offset=0;
|
|
6645
|
-
return (
|
|
6705
|
+
return ( uint8_t*)(( char*) obj+offset);
|
|
6646
6706
|
}
|
|
6647
|
-
static inline double
|
|
6707
|
+
static inline double RandomNormalData_get__sin_rot_s(const RandomNormalData restrict obj){
|
|
6648
6708
|
int64_t offset=0;
|
|
6649
6709
|
offset+=8;
|
|
6650
6710
|
return *( double*)(( char*) obj+offset);
|
|
6651
6711
|
}
|
|
6652
|
-
static inline void
|
|
6712
|
+
static inline void RandomNormalData_set__sin_rot_s(RandomNormalData restrict obj, double value){
|
|
6653
6713
|
int64_t offset=0;
|
|
6654
6714
|
offset+=8;
|
|
6655
6715
|
*( double*)(( char*) obj+offset)=value;
|
|
6656
6716
|
}
|
|
6657
|
-
static inline double*
|
|
6717
|
+
static inline double* RandomNormalData_getp__sin_rot_s(RandomNormalData restrict obj){
|
|
6658
6718
|
int64_t offset=0;
|
|
6659
6719
|
offset+=8;
|
|
6660
6720
|
return ( double*)(( char*) obj+offset);
|
|
6661
6721
|
}
|
|
6662
|
-
static inline double
|
|
6722
|
+
static inline double RandomNormalData_get__cos_rot_s(const RandomNormalData restrict obj){
|
|
6663
6723
|
int64_t offset=0;
|
|
6664
6724
|
offset+=16;
|
|
6665
6725
|
return *( double*)(( char*) obj+offset);
|
|
6666
6726
|
}
|
|
6667
|
-
static inline void
|
|
6727
|
+
static inline void RandomNormalData_set__cos_rot_s(RandomNormalData restrict obj, double value){
|
|
6668
6728
|
int64_t offset=0;
|
|
6669
6729
|
offset+=16;
|
|
6670
6730
|
*( double*)(( char*) obj+offset)=value;
|
|
6671
6731
|
}
|
|
6672
|
-
static inline double*
|
|
6732
|
+
static inline double* RandomNormalData_getp__cos_rot_s(RandomNormalData restrict obj){
|
|
6673
6733
|
int64_t offset=0;
|
|
6674
6734
|
offset+=16;
|
|
6675
6735
|
return ( double*)(( char*) obj+offset);
|
|
6676
6736
|
}
|
|
6677
|
-
static inline double
|
|
6737
|
+
static inline double RandomNormalData_get__shift_x(const RandomNormalData restrict obj){
|
|
6678
6738
|
int64_t offset=0;
|
|
6679
6739
|
offset+=24;
|
|
6680
6740
|
return *( double*)(( char*) obj+offset);
|
|
6681
6741
|
}
|
|
6682
|
-
static inline void
|
|
6742
|
+
static inline void RandomNormalData_set__shift_x(RandomNormalData restrict obj, double value){
|
|
6683
6743
|
int64_t offset=0;
|
|
6684
6744
|
offset+=24;
|
|
6685
6745
|
*( double*)(( char*) obj+offset)=value;
|
|
6686
6746
|
}
|
|
6687
|
-
static inline double*
|
|
6747
|
+
static inline double* RandomNormalData_getp__shift_x(RandomNormalData restrict obj){
|
|
6688
6748
|
int64_t offset=0;
|
|
6689
6749
|
offset+=24;
|
|
6690
6750
|
return ( double*)(( char*) obj+offset);
|
|
6691
6751
|
}
|
|
6692
|
-
static inline
|
|
6752
|
+
static inline double RandomNormalData_get__shift_y(const RandomNormalData restrict obj){
|
|
6693
6753
|
int64_t offset=0;
|
|
6694
6754
|
offset+=32;
|
|
6695
|
-
return *((
|
|
6755
|
+
return *( double*)(( char*) obj+offset);
|
|
6696
6756
|
}
|
|
6697
|
-
static inline void
|
|
6757
|
+
static inline void RandomNormalData_set__shift_y(RandomNormalData restrict obj, double value){
|
|
6698
6758
|
int64_t offset=0;
|
|
6699
6759
|
offset+=32;
|
|
6700
|
-
*((
|
|
6760
|
+
*( double*)(( char*) obj+offset)=value;
|
|
6701
6761
|
}
|
|
6702
|
-
static inline
|
|
6762
|
+
static inline double* RandomNormalData_getp__shift_y(RandomNormalData restrict obj){
|
|
6703
6763
|
int64_t offset=0;
|
|
6704
6764
|
offset+=32;
|
|
6705
|
-
return (
|
|
6765
|
+
return ( double*)(( char*) obj+offset);
|
|
6706
6766
|
}
|
|
6707
|
-
static inline double
|
|
6767
|
+
static inline double RandomNormalData_get__shift_s(const RandomNormalData restrict obj){
|
|
6708
6768
|
int64_t offset=0;
|
|
6709
6769
|
offset+=40;
|
|
6710
6770
|
return *( double*)(( char*) obj+offset);
|
|
6711
6771
|
}
|
|
6712
|
-
static inline void
|
|
6772
|
+
static inline void RandomNormalData_set__shift_s(RandomNormalData restrict obj, double value){
|
|
6713
6773
|
int64_t offset=0;
|
|
6714
6774
|
offset+=40;
|
|
6715
6775
|
*( double*)(( char*) obj+offset)=value;
|
|
6716
6776
|
}
|
|
6717
|
-
static inline double*
|
|
6777
|
+
static inline double* RandomNormalData_getp__shift_s(RandomNormalData restrict obj){
|
|
6718
6778
|
int64_t offset=0;
|
|
6719
6779
|
offset+=40;
|
|
6720
6780
|
return ( double*)(( char*) obj+offset);
|
|
6721
6781
|
}
|
|
6722
|
-
static inline double
|
|
6782
|
+
static inline double RandomNormalData_get__rot_x_rad(const RandomNormalData restrict obj){
|
|
6723
6783
|
int64_t offset=0;
|
|
6724
6784
|
offset+=48;
|
|
6725
6785
|
return *( double*)(( char*) obj+offset);
|
|
6726
6786
|
}
|
|
6727
|
-
static inline void
|
|
6787
|
+
static inline void RandomNormalData_set__rot_x_rad(RandomNormalData restrict obj, double value){
|
|
6728
6788
|
int64_t offset=0;
|
|
6729
6789
|
offset+=48;
|
|
6730
6790
|
*( double*)(( char*) obj+offset)=value;
|
|
6731
6791
|
}
|
|
6732
|
-
static inline double*
|
|
6792
|
+
static inline double* RandomNormalData_getp__rot_x_rad(RandomNormalData restrict obj){
|
|
6733
6793
|
int64_t offset=0;
|
|
6734
6794
|
offset+=48;
|
|
6735
6795
|
return ( double*)(( char*) obj+offset);
|
|
6736
6796
|
}
|
|
6737
|
-
static inline double
|
|
6797
|
+
static inline double RandomNormalData_get__rot_y_rad(const RandomNormalData restrict obj){
|
|
6738
6798
|
int64_t offset=0;
|
|
6739
6799
|
offset+=56;
|
|
6740
6800
|
return *( double*)(( char*) obj+offset);
|
|
6741
6801
|
}
|
|
6742
|
-
static inline void
|
|
6802
|
+
static inline void RandomNormalData_set__rot_y_rad(RandomNormalData restrict obj, double value){
|
|
6743
6803
|
int64_t offset=0;
|
|
6744
6804
|
offset+=56;
|
|
6745
6805
|
*( double*)(( char*) obj+offset)=value;
|
|
6746
6806
|
}
|
|
6747
|
-
static inline double*
|
|
6807
|
+
static inline double* RandomNormalData_getp__rot_y_rad(RandomNormalData restrict obj){
|
|
6748
6808
|
int64_t offset=0;
|
|
6749
6809
|
offset+=56;
|
|
6750
6810
|
return ( double*)(( char*) obj+offset);
|
|
6751
6811
|
}
|
|
6752
|
-
static inline double
|
|
6812
|
+
static inline double RandomNormalData_get__rot_s_rad_no_frame(const RandomNormalData restrict obj){
|
|
6753
6813
|
int64_t offset=0;
|
|
6754
6814
|
offset+=64;
|
|
6755
6815
|
return *( double*)(( char*) obj+offset);
|
|
6756
6816
|
}
|
|
6757
|
-
static inline void
|
|
6817
|
+
static inline void RandomNormalData_set__rot_s_rad_no_frame(RandomNormalData restrict obj, double value){
|
|
6758
6818
|
int64_t offset=0;
|
|
6759
6819
|
offset+=64;
|
|
6760
6820
|
*( double*)(( char*) obj+offset)=value;
|
|
6761
6821
|
}
|
|
6762
|
-
static inline double*
|
|
6822
|
+
static inline double* RandomNormalData_getp__rot_s_rad_no_frame(RandomNormalData restrict obj){
|
|
6763
6823
|
int64_t offset=0;
|
|
6764
6824
|
offset+=64;
|
|
6765
6825
|
return ( double*)(( char*) obj+offset);
|
|
6766
6826
|
}
|
|
6767
|
-
static inline double
|
|
6827
|
+
static inline double RandomNormalData_get_rot_shift_anchor(const RandomNormalData restrict obj){
|
|
6768
6828
|
int64_t offset=0;
|
|
6769
6829
|
offset+=72;
|
|
6770
6830
|
return *( double*)(( char*) obj+offset);
|
|
6771
6831
|
}
|
|
6772
|
-
static inline void
|
|
6832
|
+
static inline void RandomNormalData_set_rot_shift_anchor(RandomNormalData restrict obj, double value){
|
|
6773
6833
|
int64_t offset=0;
|
|
6774
6834
|
offset+=72;
|
|
6775
6835
|
*( double*)(( char*) obj+offset)=value;
|
|
6776
6836
|
}
|
|
6777
|
-
static inline double*
|
|
6837
|
+
static inline double* RandomNormalData_getp_rot_shift_anchor(RandomNormalData restrict obj){
|
|
6778
6838
|
int64_t offset=0;
|
|
6779
6839
|
offset+=72;
|
|
6780
6840
|
return ( double*)(( char*) obj+offset);
|
|
6781
|
-
}
|
|
6782
|
-
static inline double RandomRutherfordData_get__rot_x_rad(const RandomRutherfordData restrict obj){
|
|
6783
|
-
int64_t offset=0;
|
|
6784
|
-
offset+=80;
|
|
6785
|
-
return *( double*)(( char*) obj+offset);
|
|
6786
|
-
}
|
|
6787
|
-
static inline void RandomRutherfordData_set__rot_x_rad(RandomRutherfordData restrict obj, double value){
|
|
6788
|
-
int64_t offset=0;
|
|
6789
|
-
offset+=80;
|
|
6790
|
-
*( double*)(( char*) obj+offset)=value;
|
|
6791
|
-
}
|
|
6792
|
-
static inline double* RandomRutherfordData_getp__rot_x_rad(RandomRutherfordData restrict obj){
|
|
6793
|
-
int64_t offset=0;
|
|
6794
|
-
offset+=80;
|
|
6795
|
-
return ( double*)(( char*) obj+offset);
|
|
6796
|
-
}
|
|
6797
|
-
static inline double RandomRutherfordData_get__rot_y_rad(const RandomRutherfordData restrict obj){
|
|
6798
|
-
int64_t offset=0;
|
|
6799
|
-
offset+=88;
|
|
6800
|
-
return *( double*)(( char*) obj+offset);
|
|
6801
|
-
}
|
|
6802
|
-
static inline void RandomRutherfordData_set__rot_y_rad(RandomRutherfordData restrict obj, double value){
|
|
6803
|
-
int64_t offset=0;
|
|
6804
|
-
offset+=88;
|
|
6805
|
-
*( double*)(( char*) obj+offset)=value;
|
|
6806
|
-
}
|
|
6807
|
-
static inline double* RandomRutherfordData_getp__rot_y_rad(RandomRutherfordData restrict obj){
|
|
6808
|
-
int64_t offset=0;
|
|
6809
|
-
offset+=88;
|
|
6810
|
-
return ( double*)(( char*) obj+offset);
|
|
6811
|
-
}
|
|
6812
|
-
static inline double RandomRutherfordData_get__rot_s_rad_no_frame(const RandomRutherfordData restrict obj){
|
|
6813
|
-
int64_t offset=0;
|
|
6814
|
-
offset+=96;
|
|
6815
|
-
return *( double*)(( char*) obj+offset);
|
|
6816
|
-
}
|
|
6817
|
-
static inline void RandomRutherfordData_set__rot_s_rad_no_frame(RandomRutherfordData restrict obj, double value){
|
|
6818
|
-
int64_t offset=0;
|
|
6819
|
-
offset+=96;
|
|
6820
|
-
*( double*)(( char*) obj+offset)=value;
|
|
6821
|
-
}
|
|
6822
|
-
static inline double* RandomRutherfordData_getp__rot_s_rad_no_frame(RandomRutherfordData restrict obj){
|
|
6823
|
-
int64_t offset=0;
|
|
6824
|
-
offset+=96;
|
|
6825
|
-
return ( double*)(( char*) obj+offset);
|
|
6826
|
-
}
|
|
6827
|
-
static inline double RandomRutherfordData_get_rot_shift_anchor(const RandomRutherfordData restrict obj){
|
|
6828
|
-
int64_t offset=0;
|
|
6829
|
-
offset+=104;
|
|
6830
|
-
return *( double*)(( char*) obj+offset);
|
|
6831
|
-
}
|
|
6832
|
-
static inline void RandomRutherfordData_set_rot_shift_anchor(RandomRutherfordData restrict obj, double value){
|
|
6833
|
-
int64_t offset=0;
|
|
6834
|
-
offset+=104;
|
|
6835
|
-
*( double*)(( char*) obj+offset)=value;
|
|
6836
|
-
}
|
|
6837
|
-
static inline double* RandomRutherfordData_getp_rot_shift_anchor(RandomRutherfordData restrict obj){
|
|
6838
|
-
int64_t offset=0;
|
|
6839
|
-
offset+=104;
|
|
6840
|
-
return ( double*)(( char*) obj+offset);
|
|
6841
6841
|
}
|
|
6842
6842
|
#endif
|
|
6843
6843
|
// copyright ############################### //
|
|
@@ -7049,11 +7049,11 @@ void Drift_single_particle(LocalParticle* part, double length){
|
|
|
7049
7049
|
|
|
7050
7050
|
#endif // XSTUITE_TRACK_FLAGS_H
|
|
7051
7051
|
|
|
7052
|
-
#include <random/random_src/
|
|
7052
|
+
#include <random/random_src/normal.h>
|
|
7053
7053
|
|
|
7054
7054
|
|
|
7055
|
-
void
|
|
7056
|
-
|
|
7055
|
+
void sample_gauss(
|
|
7056
|
+
RandomNormalData el,
|
|
7057
7057
|
|
|
7058
7058
|
ParticlesData particles,
|
|
7059
7059
|
double* samples, int64_t n_samples_per_seed,
|
|
@@ -7101,7 +7101,7 @@ void Drift_single_particle(LocalParticle* part, double length){
|
|
|
7101
7101
|
if (part_id<part_capacity){
|
|
7102
7102
|
Particles_to_LocalParticle(particles, &lpart, part_id, end_id);
|
|
7103
7103
|
if (check_is_active(&lpart)>0){
|
|
7104
|
-
|
|
7104
|
+
RandomNormal_sample(el, &lpart, samples, n_samples_per_seed);
|
|
7105
7105
|
|
|
7106
7106
|
}
|
|
7107
7107
|
if (check_is_active(&lpart)>0 && flag_increment_at_element){
|