Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/examples/advanced/microbeam/src/EMField.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /examples/advanced/microbeam/src/EMField.cc (Version 11.3.0) and /examples/advanced/microbeam/src/EMField.cc (Version 9.4.p4)


  1 //                                                  1 
  2 // *******************************************    
  3 // * License and Disclaimer                       
  4 // *                                              
  5 // * The  Geant4 software  is  copyright of th    
  6 // * the Geant4 Collaboration.  It is provided    
  7 // * conditions of the Geant4 Software License    
  8 // * LICENSE and available at  http://cern.ch/    
  9 // * include a list of copyright holders.         
 10 // *                                              
 11 // * Neither the authors of this software syst    
 12 // * institutes,nor the agencies providing fin    
 13 // * work  make  any representation or  warran    
 14 // * regarding  this  software system or assum    
 15 // * use.  Please see the license in the file     
 16 // * for the full disclaimer and the limitatio    
 17 // *                                              
 18 // * This  code  implementation is the result     
 19 // * technical work of the GEANT4 collaboratio    
 20 // * By using,  copying,  modifying or  distri    
 21 // * any work based  on the software)  you  ag    
 22 // * use  in  resulting  scientific  publicati    
 23 // * acceptance of all terms of the Geant4 Sof    
 24 // *******************************************    
 25 //                                                
 26 // This example is provided by the Geant4-DNA     
 27 // Any report or published results obtained us    
 28 // shall cite the following Geant4-DNA collabo    
 29 // Med. Phys. 37 (2010) 4692-4708                 
 30 // The Geant4-DNA web site is available at htt    
 31 //                                                
 32 // If you use this example, please cite the fo    
 33 // Rad. Prot. Dos. 133 (2009) 2-11                
 34 //                                                
 35 // Based on purging magnet advanced example.      
 36 //                                                
 37                                                   
 38 #include "EMField.hh"                             
 39 #include "G4Exp.hh"                               
 40 #include "G4SystemOfUnits.hh"                     
 41                                                   
 42 EMField::EMField()                                
 43 {}                                                
 44                                                   
 45 void EMField::GetFieldValue(const double point    
 46 {                                                 
 47   // Magnetic field                               
 48   Bfield[0] = 0;                                  
 49   Bfield[1] = 0;                                  
 50   Bfield[2] = 0;                                  
 51                                                   
 52   // Electric field                               
 53   Bfield[3] = 0;                                  
 54   Bfield[4] = 0;                                  
 55   Bfield[5] = 0;                                  
 56                                                   
 57   G4double Bx = 0;                                
 58   G4double By = 0;                                
 59   G4double Bz = 0;                                
 60                                                   
 61   G4double x = point[0];                          
 62   G4double y = point[1];                          
 63   G4double z = point[2];                          
 64                                                   
 65 // ***********************                        
 66 // AIFIRA SWITCHING MAGNET                        
 67 // ***********************                        
 68                                                   
 69   // MAGNETIC FIELD VALUE FOR 3 MeV ALPHAS        
 70   G4double switchingField = 0.0589768635 * tes    
 71                                                   
 72   // BEAM START                                   
 73   G4double beamStart = -10*m;                     
 74                                                   
 75   // RADIUS                                       
 76   G4double Rp = 0.698*m;                          
 77                                                   
 78   // ENTRANCE POSITION AFTER ANALYSIS MAGNET      
 79   G4double zS = 975*mm;                           
 80                                                   
 81   // POLE GAP                                     
 82   G4double D = 31.8*mm;                           
 83                                                   
 84   // FRINGING FIELD                               
 85                                                   
 86   G4double fieldBoundary, wc0, wc1, wc2, wc3,     
 87                                                   
 88   limitMinEntrance = beamStart+zS-4*D;            
 89   limitMaxEntrance = beamStart+zS+4*D;            
 90   limitMinExit =Rp-4*D;                           
 91   limitMaxExit =Rp+4*D;                           
 92                                                   
 93   wc0 = 0.3835;                                   
 94   wc1 = 2.388;                                    
 95   wc2 = -0.8171;                                  
 96   wc3 = 0.200;                                    
 97                                                   
 98   fieldBoundary=0.62;                             
 99                                                   
100   G4double ws, largeS, h, dhdlargeS, dhds, dla    
101                                                   
102 // - ENTRANCE OF SWITCHING MAGNET                 
103                                                   
104 if ( (z >= limitMinEntrance) && (z < limitMaxE    
105 {                                                 
106   zs0 = fieldBoundary*D;                          
107   ws = (-z+beamStart+zS-zs0)/D;                   
108   dsdz = -1/D;                                    
109   dsdx = 0;                                       
110                                                   
111   largeS = wc0 + wc1*ws + wc2*ws*ws + wc3*ws*w    
112   h = 1./(1.+G4Exp(largeS));                      
113   dhdlargeS = -G4Exp(largeS)*h*h;                 
114   dlargeSds = wc1+ 2*wc2*ws + 3*wc3*ws*ws;        
115   dhds = dhdlargeS * dlargeSds;                   
116                                                   
117   By = switchingField * h ;                       
118   Bx = y*switchingField*dhds*dsdx;                
119   Bz = y*switchingField*dhds*dsdz;                
120                                                   
121 }                                                 
122                                                   
123 // - HEART OF SWITCHING MAGNET                    
124                                                   
125  if (                                             
126           (z >= limitMaxEntrance)                 
127      &&   (( x*x + (z -(beamStart+zS))*(z -(be    
128     )                                             
129 {                                                 
130    Bx=0;                                          
131    By = switchingField;                           
132    Bz=0;                                          
133 }                                                 
134                                                   
135 // - EXIT OF SWITCHING MAGNET                     
136                                                   
137 if (                                              
138         (z >= limitMaxEntrance)                   
139      && (( x*x + (z -(beamStart+zS))*(z -(beam    
140      && (( x*x + (z -(beamStart+zS))*(z -(beam    
141                                                   
142    )                                              
143 {                                                 
144                                                   
145   xcenter = 0;                                    
146   zcenter =  beamStart+zS;                        
147                                                   
148   Rs0 = Rp + D*fieldBoundary;                     
149   ws = (std::sqrt((z-zcenter)*(z-zcenter)+(x-x    
150                                                   
151   dsdz = (1/D)*(z-zcenter)/std::sqrt((z-zcente    
152   dsdx = (1/D)*(x-xcenter)/std::sqrt((z-zcente    
153                                                   
154   largeS = wc0 + wc1*ws + wc2*ws*ws + wc3*ws*w    
155   h = 1./(1.+G4Exp(largeS));                      
156   dhdlargeS = -G4Exp(largeS)*h*h;                 
157   dlargeSds = wc1+ 2*wc2*ws + 3*wc3*ws*ws;        
158   dhds = dhdlargeS * dlargeSds;                   
159                                                   
160   By = switchingField * h ;                       
161   Bx = y*switchingField*dhds*dsdx;                
162   Bz = y*switchingField*dhds*dsdz;                
163                                                   
164 }                                                 
165                                                   
166 // **************************                     
167 // MICROBEAM LINE QUADRUPOLES                     
168 // **************************                     
169                                                   
170   // MICROBEAM LINE ANGLE                         
171   G4double lineAngle = -10*deg;                   
172                                                   
173   // X POSITION OF FIRST QUADRUPOLE               
174   G4double lineX = -1295.59*mm;                   
175                                                   
176   // Z POSITION OF FIRST QUADRUPOLE               
177   G4double lineZ = -1327*mm;                      
178                                                   
179   // Adjust magnetic zone absolute position       
180   lineX = lineX + 5.24*micrometer*std::cos(-li    
181   lineZ = lineZ + 5.24*micrometer*std::sin(-li    
182                                                   
183   // QUADRUPOLE HALF LENGTH                       
184   G4double quadHalfLength = 75*mm;                
185                                                   
186   // QUADRUPOLE SPACING                           
187   G4double quadSpacing = 40*mm;                   
188                                                   
189   // QUADRUPOLE CENTER COORDINATES                
190   G4double xoprime, zoprime;                      
191                                                   
192 if (z>=-1400*mm && z <-200*mm)                    
193 {                                                 
194   Bx=0; By=0; Bz=0;                               
195                                                   
196   // FRINGING FILED CONSTANTS                     
197   G4double c0[4], c1[4], c2[4], z1[4], z2[4],     
198                                                   
199   // QUADRUPOLE 1                                 
200   c0[0] = -5.;                                    
201   c1[0] = 2.5;                                    
202   c2[0] = -0.1;                                   
203   z1[0] = 60*mm;                                  
204   z2[0] = 130*mm;                                 
205   a0[0] = 10*mm;                                  
206   gradient[0] = 3.406526 *tesla/m;                
207                                                   
208   // QUADRUPOLE 2                                 
209   c0[1] = -5.;                                    
210   c1[1] = 2.5;                                    
211   c2[1] = -0.1;                                   
212   z1[1] = 60*mm;                                  
213   z2[1] = 130*mm;                                 
214   a0[1] = 10*mm;                                  
215   gradient[1] = -8.505263 *tesla/m;               
216                                                   
217   // QUADRUPOLE 3                                 
218   c0[2] = -5.;                                    
219   c1[2] = 2.5;                                    
220   c2[2] = -0.1;                                   
221   z1[2] = 60*mm;                                  
222   z2[2] = 130*mm;                                 
223   a0[2] = 10*mm;                                  
224   gradient[2] = 8.505263 *tesla/m;                
225                                                   
226   // QUADRUPOLE 4                                 
227   c0[3] = -5.;                                    
228   c1[3] = 2.5;                                    
229   c2[3] = -0.1;                                   
230   z1[3] = 60*mm;                                  
231   z2[3] = 130*mm;                                 
232   a0[3] = 10*mm;                                  
233   gradient[3] = -3.406526*tesla/m;                
234                                                   
235   // FIELD CREATED BY A QUADRUPOLE IN ITS LOCA    
236   G4double Bx_local,By_local,Bz_local;            
237   Bx_local = 0; By_local = 0; Bz_local = 0;       
238                                                   
239   // FIELD CREATED BY A QUADRUPOOLE IN WORLD F    
240   G4double Bx_quad,By_quad,Bz_quad;               
241   Bx_quad = 0; By_quad=0; Bz_quad=0;              
242                                                   
243   // QUADRUPOLE FRAME                             
244   G4double x_local,y_local,z_local;               
245   x_local= 0; y_local=0; z_local=0;               
246                                                   
247   G4double vars = 0;                              
248   G4double G0, G1, G2, G3;                        
249   G4double K1, K2, K3;                            
250   G4double P0, P1, P2,     cte;                   
251                                                   
252   K1=0;                                           
253   K2=0;                                           
254   K3=0;                                           
255   P0=0;                                           
256   P1=0;                                           
257   P2=0;                                           
258   G0=0;                                           
259   G1=0;                                           
260   G2=0;                                           
261   G3=0;                                           
262   cte=0;                                          
263                                                   
264   G4bool largeScattering=false;                   
265                                                   
266   for (G4int i=0;i<4; i++)                        
267   {                                               
268                                                   
269    if (i==0)                                      
270     { xoprime = lineX + quadHalfLength*std::si    
271       zoprime = lineZ + quadHalfLength*std::co    
272                                                   
273       x_local = (x - xoprime) * std::cos (line    
274       y_local = y;                                
275       z_local = (z - zoprime) * std::cos (line    
276       if (std::sqrt(x_local*x_local+y_local*y_    
277                                                   
278     }                                             
279                                                   
280    if (i==1)                                      
281     { xoprime = lineX + (3*quadHalfLength+quad    
282       zoprime = lineZ + (3*quadHalfLength+quad    
283                                                   
284       x_local = (x - xoprime) * std::cos (line    
285       y_local = y;                                
286       z_local = (z - zoprime) * std::cos (line    
287       if (std::sqrt(x_local*x_local+y_local*y_    
288     }                                             
289                                                   
290    if (i==2)                                      
291     { xoprime = lineX + (5*quadHalfLength+2*qu    
292       zoprime = lineZ + (5*quadHalfLength+2*qu    
293                                                   
294       x_local = (x - xoprime) * std::cos (line    
295       y_local = y;                                
296       z_local = (z - zoprime) * std::cos (line    
297       if (std::sqrt(x_local*x_local+y_local*y_    
298     }                                             
299                                                   
300    if (i==3)                                      
301     { xoprime = lineX + (7*quadHalfLength+3*qu    
302       zoprime = lineZ + (7*quadHalfLength+3*qu    
303                                                   
304       x_local = (x - xoprime) * std::cos (line    
305       y_local = y;                                
306       z_local = (z - zoprime) * std::cos (line    
307       if (std::sqrt(x_local*x_local+y_local*y_    
308     }                                             
309                                                   
310                                                   
311    if ( z_local < -z2[i] )                        
312    {                                              
313     G0=0;                                         
314     G1=0;                                         
315     G2=0;                                         
316     G3=0;                                         
317    }                                              
318                                                   
319    if ( z_local > z2[i] )                         
320    {                                              
321     G0=0;                                         
322     G1=0;                                         
323     G2=0;                                         
324     G3=0;                                         
325    }                                              
326                                                   
327    if ( (z_local>=-z1[i]) & (z_local<=z1[i]) )    
328    {                                              
329     G0=gradient[i];                               
330     G1=0;                                         
331     G2=0;                                         
332     G3=0;                                         
333    }                                              
334                                                   
335    if ( ((z_local>=-z2[i]) & (z_local<-z1[i]))    
336    {                                              
337                                                   
338     vars = ( z_local - z1[i]) / a0[i] ;           
339       if (z_local<-z1[i]) vars = ( - z_local -    
340                                                   
341                                                   
342     P0 = c0[i]+c1[i]*vars+c2[i]*vars*vars;        
343                                                   
344     P1 = c1[i]/a0[i]+2*c2[i]*(z_local-z1[i])/a    
345     if (z_local<-z1[i])  P1 = -c1[i]/a0[i]+2*c    
346                                                   
347     P2 = 2*c2[i]/a0[i]/a0[i];                     
348                                                   
349     cte = 1 + G4Exp(c0[i]);                       
350                                                   
351     K1 = -cte*P1*G4Exp(P0)/( (1+G4Exp(P0))*(1+    
352                                                   
353     K2 = -cte*G4Exp(P0)*(                         
354      P2/( (1+G4Exp(P0))*(1+G4Exp(P0)) )           
355     +2*P1*K1/(1+G4Exp(P0))/cte                    
356     +P1*P1/(1+G4Exp(P0))/(1+G4Exp(P0))            
357     );                                            
358                                                   
359     K3 = -cte*G4Exp(P0)*(                         
360     (3*P2*P1+P1*P1*P1)/(1+G4Exp(P0))/(1+G4Exp(    
361     +4*K1*(P1*P1+P2)/(1+G4Exp(P0))/cte            
362     +2*P1*(K1*K1/cte/cte+K2/(1+G4Exp(P0))/cte)    
363      );                                           
364                                                   
365     G0 = gradient[i]*cte/(1+G4Exp(P0));           
366     G1 = gradient[i]*K1;                          
367     G2 = gradient[i]*K2;                          
368     G3 = gradient[i]*K3;                          
369                                                   
370    }                                              
371                                                   
372    // PROTECTION AGAINST LARGE SCATTERING         
373                                                   
374    if ( largeScattering )                         
375    {                                              
376     G0=0;                                         
377     G1=0;                                         
378     G2=0;                                         
379     G3=0;                                         
380    }                                              
381                                                   
382    // MAGNETIC FIELD COMPUTATION FOR EACH QUAD    
383                                                   
384    Bx_local = y_local*(G0-(1./12)*(3*x_local*x    
385    By_local = x_local*(G0-(1./12)*(3*y_local*y    
386    Bz_local = x_local*y_local*(G1-(1./12)*(x_l    
387                                                   
388    Bx_quad = Bz_local*std::sin(lineAngle)+Bx_l    
389    By_quad = By_local;                            
390    Bz_quad = Bz_local*std::cos(lineAngle)-Bx_l    
391                                                   
392    // TOTAL MAGNETIC FIELD                        
393                                                   
394    Bx = Bx + Bx_quad ;                            
395    By = By + By_quad ;                            
396    Bz = Bz + Bz_quad ;                            
397                                                   
398   } // LOOP ON QUADRUPOLES                        
399                                                   
400                                                   
401 } // END OF QUADRUPLET                            
402                                                   
403   Bfield[0] = Bx;                                 
404   Bfield[1] = By;                                 
405   Bfield[2] = Bz;                                 
406                                                   
407 // *****************************************      
408 // ELECTRIC FIELD CREATED BY SCANNING PLATES      
409 // *****************************************      
410                                                   
411   Bfield[3] = 0;                                  
412   Bfield[4] = 0;                                  
413   Bfield[5] = 0;                                  
414                                                   
415   // POSITION OF EXIT OF LAST QUAD WHERE THE S    
416                                                   
417   G4double electricPlateWidth1 = 5 * mm;          
418   G4double electricPlateWidth2 = 5 * mm;          
419   G4double electricPlateLength1 = 36 * mm;        
420   G4double electricPlateLength2 = 34 * mm;        
421   G4double electricPlateGap = 5 * mm;             
422   G4double electricPlateSpacing1 = 3 * mm;        
423   G4double electricPlateSpacing2 = 4 * mm;        
424                                                   
425   // APPLY VOLTAGE HERE IN VOLTS (no electrost    
426   G4double electricPlateVoltage1 = 0 * volt;      
427   G4double electricPlateVoltage2 = 0 * volt;      
428                                                   
429   G4double electricFieldPlate1 = electricPlate    
430   G4double electricFieldPlate2 = electricPlate    
431                                                   
432   G4double  beginFirstZoneX = lineX + (8*quadH    
433   G4double  beginFirstZoneZ = lineZ + (8*quadH    
434                                                   
435   G4double  beginSecondZoneX = lineX + (8*quad    
436   G4double  beginSecondZoneZ = lineZ + (8*quad    
437                                                   
438   G4double xA, zA, xB, zB, xC, zC, xD, zD;        
439   G4double slope1, cte1, slope2, cte2, slope3,    
440                                                   
441   // WARNING : lineAngle < 0                      
442                                                   
443   // FIRST PLATES                                 
444                                                   
445   xA = beginFirstZoneX + std::cos(lineAngle)*e    
446   zA = beginFirstZoneZ - std::sin(lineAngle)*e    
447                                                   
448   xB = xA + std::sin(lineAngle)*electricPlateL    
449   zB = zA + std::cos(lineAngle)*electricPlateL    
450                                                   
451   xC = xB - std::cos(lineAngle)*electricPlateS    
452   zC = zB + std::sin(lineAngle)*electricPlateS    
453                                                   
454   xD = xC - std::sin(lineAngle)*electricPlateL    
455   zD = zC - std::cos(lineAngle)*electricPlateL    
456                                                   
457   slope1 = (xB-xA)/(zB-zA);                       
458   cte1 = xA - slope1 * zA;                        
459                                                   
460   slope2 = (xC-xB)/(zC-zB);                       
461   cte2 = xB - slope2 * zB;                        
462                                                   
463   slope3 = (xD-xC)/(zD-zC);                       
464   cte3 = xC - slope3 * zC;                        
465                                                   
466   slope4 = (xA-xD)/(zA-zD);                       
467   cte4 = xD - slope4 * zD;                        
468                                                   
469                                                   
470   if                                              
471   (                                               
472        x <= slope1 * z + cte1                     
473     && x >= slope3 * z + cte3                     
474     && x <= slope4 * z + cte4                     
475     && x >= slope2 * z + cte2                     
476     && std::abs(y)<=electricPlateWidth1/2         
477   )                                               
478                                                   
479   {                                               
480       Bfield[3] = electricFieldPlate1*std::cos    
481       Bfield[4] = 0;                              
482       Bfield[5] = -electricFieldPlate1*std::si    
483                                                   
484   }                                               
485                                                   
486   // SECOND PLATES                                
487                                                   
488   xA = beginSecondZoneX + std::cos(lineAngle)*    
489   zA = beginSecondZoneZ - std::sin(lineAngle)*    
490                                                   
491   xB = xA + std::sin(lineAngle)*electricPlateL    
492   zB = zA + std::cos(lineAngle)*electricPlateL    
493                                                   
494   xC = xB - std::cos(lineAngle)*electricPlateW    
495   zC = zB + std::sin(lineAngle)*electricPlateW    
496                                                   
497   xD = xC - std::sin(lineAngle)*electricPlateL    
498   zD = zC - std::cos(lineAngle)*electricPlateL    
499                                                   
500   slope1 = (xB-xA)/(zB-zA);                       
501   cte1 = xA - slope1 * zA;                        
502                                                   
503   slope2 = (xC-xB)/(zC-zB);                       
504   cte2 = xB - slope2 * zB;                        
505                                                   
506   slope3 = (xD-xC)/(zD-zC);                       
507   cte3 = xC - slope3 * zC;                        
508                                                   
509   slope4 = (xA-xD)/(zA-zD);                       
510   cte4 = xD - slope4 * zD;                        
511                                                   
512   if                                              
513   (                                               
514        x <= slope1 * z + cte1                     
515     && x >= slope3 * z + cte3                     
516     && x <= slope4 * z + cte4                     
517     && x >= slope2 * z + cte2                     
518     && std::abs(y)<=electricPlateSpacing2/2       
519   )                                               
520                                                   
521   {                                               
522       Bfield[3] = 0;                              
523       Bfield[4] = electricFieldPlate2;            
524       Bfield[5] = 0;                              
525   }                                               
526                                                   
527 }                                                 
528