more python 3.12 fixes

Frederic Perez · Frederic Perez · commit 2ab71da3c3db · 2024-10-24T15:11:12.000+02:00
diff --git a/src/ElectroMagn/Laser.cpp b/src/ElectroMagn/Laser.cpp
@@ -453,12 +453,9 @@ void LaserProfileSeparable::initFields( Params &params, Patch *patch, ElectroMag
 double LaserProfileSeparable::getAmplitude( std::vector<double>, double t, int j, int k )
 {
     double amp;
-    #pragma omp critical
-    {
-        double omega = omega_ * chirpProfile_->valueAt( t );
-        double phi = ( *phase )( j, k );
-        amp = timeProfile_->valueAt( t-( phi+delay_phase_ )/omega ) * ( *space_envelope )( j, k ) * sin( omega*t - phi );
-    }
+    double omega = omega_ * chirpProfile_->valueAt( t );
+    double phi = ( *phase )( j, k );
+    amp = timeProfile_->valueAt( t-( phi+delay_phase_ )/omega ) * ( *space_envelope )( j, k ) * sin( omega*t - phi );
     return amp;
 }
 
@@ -562,10 +559,7 @@ double LaserProfileFile::getAmplitude( std::vector<double> pos, double t, int j,
     for( unsigned int i=0; i<n; i++ ) {
         amp += ( *magnitude )( j, k, i ) * cos( omega[i] * t + ( *phase )( j, k, i ) );
     }
-    #pragma omp critical
-    {
-        amp *= extraProfile->valueAt( pos, t );
-    }
+    amp *= extraProfile->valueAt( pos, t );
     return amp;
 }
 
diff --git a/src/ElectroMagn/Laser.h b/src/ElectroMagn/Laser.h
@@ -139,15 +139,13 @@ class LaserProfileNonSeparable : public LaserProfile
     inline double getAmplitude( std::vector<double> pos, double t, int, int ) override
     {
         double amp;
-        #pragma omp critical
         amp = spaceAndTimeProfile_->valueAt( pos, t );
         return amp;
     }
 
     inline std::complex<double> getAmplitudecomplex( std::vector<double> pos, double t, int, int ) override
     {
         std::complex<double> amp;
-        #pragma omp critical
         amp = spaceAndTimeProfile_->complexValueAt( pos, t );
         return amp;
     }
diff --git a/src/Ionization/IonizationFromRate.cpp b/src/Ionization/IonizationFromRate.cpp
@@ -38,14 +38,13 @@ void IonizationFromRate::operator()( Particles *particles, unsigned int ipart_mi
     
 #ifdef SMILEI_USE_NUMPY
     // Run python to evaluate the ionization rate for each particle
-    PyArrayObject *ret;
     unsigned int npart = ipart_max - ipart_min;
-    #pragma omp critical
+    SMILEI_PY_ACQUIRE_GIL
     {
         ParticleData particleData( npart );
         particleData.startAt( ipart_min );
         particleData.set( particles );
-        ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( ionization_rate_, particleData.get(), NULL );
+        PyArrayObject *ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( ionization_rate_, particleData.get(), NULL );
         PyTools::checkPyError();
         if( ret == NULL ) {
             ERROR( "ionization_rate profile has not provided a correct result" );
@@ -58,6 +57,7 @@ void IonizationFromRate::operator()( Particles *particles, unsigned int ipart_mi
         }
         Py_DECREF( ret );
     }
+    SMILEI_PY_RELEASE_GIL
 #endif
     
     
diff --git a/src/Patch/VectorPatch.cpp b/src/Patch/VectorPatch.cpp
@@ -1170,13 +1170,15 @@ void VectorPatch::finalizeSyncAndBCFields( Params &params, SmileiMPI *smpi, SimW
         }
 
         timers.maxwellBC.restart();
+        SMILEI_PY_SAVE_MASTER_THREAD
         #pragma omp for schedule(static)
         for( unsigned int ipatch=0 ; ipatch<this->size() ; ipatch++ ) {
             // Applies boundary conditions on B
             if ( (!params.is_spectral) || (params.geometry!= "AMcylindrical") )
                 ( *this )( ipatch )->EMfields->boundaryConditions( time_dual, ( *this )( ipatch ), simWindow );
 
         }
+        SMILEI_PY_RESTORE_MASTER_THREAD
         SyncVectorPatch::exchangeForPML( params, (*this), smpi );
 
         #pragma omp for schedule(static)
@@ -4963,6 +4965,7 @@ void VectorPatch::dynamicsWithoutTasks( Params &params,
     diag_PartEventTracing = smpi->diagPartEventTracing( time_dual, params.timestep);
 #endif
 
+    SMILEI_PY_SAVE_MASTER_THREAD
     #pragma omp for schedule(runtime)
         for( unsigned int ipatch=0 ; ipatch<this->size() ; ipatch++ ) {
             ( *this )( ipatch )->EMfields->restartRhoJ();
@@ -5019,6 +5022,7 @@ void VectorPatch::dynamicsWithoutTasks( Params &params,
             } // end loop on species
             //MESSAGE("species dynamics");
         } // end loop on patches
+    SMILEI_PY_RESTORE_MASTER_THREAD
 }
 
 void VectorPatch::ponderomotiveUpdateSusceptibilityAndMomentumWithoutTasks( Params &params,
diff --git a/src/Profiles/Function.cpp b/src/Profiles/Function.cpp
@@ -8,127 +8,186 @@ using namespace std;
 // 1D
 double Function_Python1D::valueAt( double time )
 {
-    return PyTools::runPyFunction( py_profile, time );
+    SMILEI_PY_ACQUIRE_GIL
+    double v = PyTools::runPyFunction( py_profile, time );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 double Function_Python1D::valueAt( vector<double>, double time )
 {
-    return PyTools::runPyFunction( py_profile, time );
+    SMILEI_PY_ACQUIRE_GIL
+    double v = PyTools::runPyFunction( py_profile, time );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 double Function_Python1D::valueAt( vector<double> x_cell )
 {
-    return PyTools::runPyFunction( py_profile, x_cell[0] );
+    SMILEI_PY_ACQUIRE_GIL
+    double v = PyTools::runPyFunction( py_profile, x_cell[0] );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 
 // 2D
 double Function_Python2D::valueAt( vector<double> x_cell, double time )
 {
-    return PyTools::runPyFunction( py_profile, x_cell[0], time );
+    SMILEI_PY_ACQUIRE_GIL
+    double v = PyTools::runPyFunction( py_profile, x_cell[0], time );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 double Function_Python2D::valueAt( vector<double> x_cell )
 {
-    return PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1] );
+    SMILEI_PY_ACQUIRE_GIL
+    double v = PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1] );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 // 2D complex
 std::complex<double> Function_Python2D::complexValueAt( vector<double> x_cell, double time )
 {
-    return PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], time );
+    SMILEI_PY_ACQUIRE_GIL
+    std::complex<double> v = PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], time );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 std::complex<double> Function_Python2D::complexValueAt( vector<double> x_cell )
 {
-    return PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1] );
+    SMILEI_PY_ACQUIRE_GIL
+    std::complex<double> v = PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1] );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 
 // 3D
 double Function_Python3D::valueAt( vector<double> x_cell, double time )
 {
-    return PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], time );
+    SMILEI_PY_ACQUIRE_GIL
+    double v = PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], time );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 double Function_Python3D::valueAt( vector<double> x_cell )
 {
-    return PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], x_cell[2] );
+    SMILEI_PY_ACQUIRE_GIL
+    double v = PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], x_cell[2] );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 // 3D complex
 std::complex<double> Function_Python3D::complexValueAt( vector<double> x_cell, double time )
 {
-    return PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1], time );
+    SMILEI_PY_ACQUIRE_GIL
+    std::complex<double> v = PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1], time );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 
 // 4D
 double Function_Python4D::valueAt( vector<double> x_cell, double time )
 {
-    return PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], x_cell[2], time );
+    SMILEI_PY_ACQUIRE_GIL
+    double v = PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], x_cell[2], time );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 // 4D complex
 std::complex<double> Function_Python4D::complexValueAt( vector<double> x_cell, double time )
 {
-    return PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1], x_cell[2], time );
+    SMILEI_PY_ACQUIRE_GIL
+    std::complex<double> v = PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1], x_cell[2], time );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 
 // Special cases for locations specified in numpy arrays
 #ifdef SMILEI_USE_NUMPY
 PyArrayObject *Function_Python1D::valueAt( std::vector<PyArrayObject *> x )
 {
-    return ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], NULL );
+    SMILEI_PY_ACQUIRE_GIL
+    PyArrayObject * v = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], NULL );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 PyArrayObject *Function_Python2D::valueAt( std::vector<PyArrayObject *> x )
 {
-    return ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], NULL );
+    SMILEI_PY_ACQUIRE_GIL
+    PyArrayObject * v = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], NULL );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 PyArrayObject *Function_Python3D::valueAt( std::vector<PyArrayObject *> x )
 {
-    return ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], NULL );
+    SMILEI_PY_ACQUIRE_GIL
+    PyArrayObject * v = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], NULL );
+    SMILEI_PY_RELEASE_GIL
+    return v;
 }
 PyArrayObject *Function_Python2D::complexValueAt( std::vector<PyArrayObject *> x )
 {
+    SMILEI_PY_ACQUIRE_GIL
     PyObject *values = PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], NULL );
     PyArrayObject *cvalues = ( PyArrayObject * )PyObject_CallMethod( values, const_cast<char *>("astype"), const_cast<char *>("s"), const_cast<char *>("complex"), NULL );
     Py_DECREF( values );
+    SMILEI_PY_RELEASE_GIL
     return cvalues;
 }
 
 // Time dependent
 
 PyArrayObject *Function_Python1D::valueAt( std::vector<PyArrayObject *>, double time )
 {
+    SMILEI_PY_ACQUIRE_GIL
     PyObject *t = PyFloat_FromDouble( time );
     PyArrayObject * ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, t, NULL );
     Py_DECREF( t );
+    SMILEI_PY_RELEASE_GIL
     return ret;
 }
 PyArrayObject *Function_Python2D::valueAt( std::vector<PyArrayObject *> x, double time  )
 {
+    SMILEI_PY_ACQUIRE_GIL
     PyObject *t = PyFloat_FromDouble( time );
     PyArrayObject * ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], t, NULL );
     Py_DECREF( t );
+    SMILEI_PY_RELEASE_GIL
     return ret;
 }
 PyArrayObject *Function_Python3D::valueAt( std::vector<PyArrayObject *> x, double time  )
 {
+    SMILEI_PY_ACQUIRE_GIL
     PyObject *t = PyFloat_FromDouble( time );
     PyArrayObject * ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], t, NULL );
     Py_DECREF( t );
+    SMILEI_PY_RELEASE_GIL
     return ret;
 }
 PyArrayObject *Function_Python4D::valueAt( std::vector<PyArrayObject *> x, double time  )
 {
+    SMILEI_PY_ACQUIRE_GIL
     PyObject *t = PyFloat_FromDouble( time );
     PyArrayObject * ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], t, NULL );
     Py_DECREF( t );
+    SMILEI_PY_RELEASE_GIL
     return ret;
 }PyArrayObject *Function_Python4D::complexValueAt( std::vector<PyArrayObject *> x, double time )
 {
+    SMILEI_PY_ACQUIRE_GIL
     PyObject *t = PyFloat_FromDouble( time );
     PyObject * values = PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], t, NULL );
     Py_DECREF( t );
     PyArrayObject *cvalues = ( PyArrayObject * )PyObject_CallMethod( values, const_cast<char *>("astype"), const_cast<char *>("s"), const_cast<char *>("complex"), NULL );
     Py_DECREF( values );
+    SMILEI_PY_RELEASE_GIL
     return cvalues;
 }
 PyArrayObject *Function_Python4D::complexValueAt( std::vector<PyArrayObject *> x, PyArrayObject *t )
 {
+    SMILEI_PY_ACQUIRE_GIL
     PyObject *values = PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], t, NULL );
     PyArrayObject *cvalues = ( PyArrayObject * )PyObject_CallMethod( values, const_cast<char *>("astype"), const_cast<char *>("s"), const_cast<char *>("complex"), NULL );
     Py_DECREF( values );
+    SMILEI_PY_RELEASE_GIL
     return cvalues;
 }
 
diff --git a/src/Tools/PyTools.h b/src/Tools/PyTools.h
@@ -44,8 +44,8 @@
 //  }
 //  SMILEI_PY_RESTORE_MASTER_THREAD
 #if PY_MAJOR_VERSION > 2 && PY_MINOR_VERSION > 11 
-    #define SMILEI_PY_SAVE_MASTER_THREAD  PyThreadState *_save = NULL; _Pragma("omp master") if( Py_IsInitialized() ) _save = PyEval_SaveThread();
-    #define SMILEI_PY_RESTORE_MASTER_THREAD _Pragma("omp master") if( Py_IsInitialized() ) PyEval_RestoreThread( _save );
+    #define SMILEI_PY_SAVE_MASTER_THREAD  PyThreadState *_save = NULL; _Pragma("omp master") if( Py_IsInitialized() ) _save = PyEval_SaveThread(); _Pragma("omp barrier")
+    #define SMILEI_PY_RESTORE_MASTER_THREAD _Pragma("omp master") if( Py_IsInitialized() ) PyEval_RestoreThread( _save ); _Pragma("omp barrier")
     #define SMILEI_PY_ACQUIRE_GIL PyGILState_STATE _state = PyGILState_Ensure();
     #define SMILEI_PY_RELEASE_GIL PyGILState_Release( _state );
 #else

Original file line number	Diff line number	Diff line change
`@@ -139,15 +139,13 @@ class LaserProfileNonSeparable : public LaserProfile`
`139`	`139`	`inline double getAmplitude( std::vector<double> pos, double t, int, int ) override`
`140`	`140`	`{`
`141`	`141`	`double amp;`
`142`		`- #pragma omp critical`
`143`	`142`	`amp = spaceAndTimeProfile_->valueAt( pos, t );`
`144`	`143`	`return amp;`
`145`	`144`	`}`
`146`	`145`
`147`	`146`	`inline std::complex<double> getAmplitudecomplex( std::vector<double> pos, double t, int, int ) override`
`148`	`147`	`{`
`149`	`148`	`std::complex<double> amp;`
`150`		`- #pragma omp critical`
`151`	`149`	`amp = spaceAndTimeProfile_->complexValueAt( pos, t );`
`152`	`150`	`return amp;`
`153`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,127 +8,186 @@ using namespace std;`
`8`	`8`	`// 1D`
`9`	`9`	`double Function_Python1D::valueAt( double time )`
`10`	`10`	`{`
`11`		`- return PyTools::runPyFunction( py_profile, time );`
	`11`	`+ SMILEI_PY_ACQUIRE_GIL`
	`12`	`+ double v = PyTools::runPyFunction( py_profile, time );`
	`13`	`+ SMILEI_PY_RELEASE_GIL`
	`14`	`+ return v;`
`12`	`15`	`}`
`13`	`16`	`double Function_Python1D::valueAt( vector<double>, double time )`
`14`	`17`	`{`
`15`		`- return PyTools::runPyFunction( py_profile, time );`
	`18`	`+ SMILEI_PY_ACQUIRE_GIL`
	`19`	`+ double v = PyTools::runPyFunction( py_profile, time );`
	`20`	`+ SMILEI_PY_RELEASE_GIL`
	`21`	`+ return v;`
`16`	`22`	`}`
`17`	`23`	`double Function_Python1D::valueAt( vector<double> x_cell )`
`18`	`24`	`{`
`19`		`- return PyTools::runPyFunction( py_profile, x_cell[0] );`
	`25`	`+ SMILEI_PY_ACQUIRE_GIL`
	`26`	`+ double v = PyTools::runPyFunction( py_profile, x_cell[0] );`
	`27`	`+ SMILEI_PY_RELEASE_GIL`
	`28`	`+ return v;`
`20`	`29`	`}`
`21`	`30`
`22`	`31`	`// 2D`
`23`	`32`	`double Function_Python2D::valueAt( vector<double> x_cell, double time )`
`24`	`33`	`{`
`25`		`- return PyTools::runPyFunction( py_profile, x_cell[0], time );`
	`34`	`+ SMILEI_PY_ACQUIRE_GIL`
	`35`	`+ double v = PyTools::runPyFunction( py_profile, x_cell[0], time );`
	`36`	`+ SMILEI_PY_RELEASE_GIL`
	`37`	`+ return v;`
`26`	`38`	`}`
`27`	`39`	`double Function_Python2D::valueAt( vector<double> x_cell )`
`28`	`40`	`{`
`29`		`- return PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1] );`
	`41`	`+ SMILEI_PY_ACQUIRE_GIL`
	`42`	`+ double v = PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1] );`
	`43`	`+ SMILEI_PY_RELEASE_GIL`
	`44`	`+ return v;`
`30`	`45`	`}`
`31`	`46`	`// 2D complex`
`32`	`47`	`std::complex<double> Function_Python2D::complexValueAt( vector<double> x_cell, double time )`
`33`	`48`	`{`
`34`		`- return PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], time );`
	`49`	`+ SMILEI_PY_ACQUIRE_GIL`
	`50`	`+ std::complex<double> v = PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], time );`
	`51`	`+ SMILEI_PY_RELEASE_GIL`
	`52`	`+ return v;`
`35`	`53`	`}`
`36`	`54`	`std::complex<double> Function_Python2D::complexValueAt( vector<double> x_cell )`
`37`	`55`	`{`
`38`		`- return PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1] );`
	`56`	`+ SMILEI_PY_ACQUIRE_GIL`
	`57`	`+ std::complex<double> v = PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1] );`
	`58`	`+ SMILEI_PY_RELEASE_GIL`
	`59`	`+ return v;`
`39`	`60`	`}`
`40`	`61`
`41`	`62`	`// 3D`
`42`	`63`	`double Function_Python3D::valueAt( vector<double> x_cell, double time )`
`43`	`64`	`{`
`44`		`- return PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], time );`
	`65`	`+ SMILEI_PY_ACQUIRE_GIL`
	`66`	`+ double v = PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], time );`
	`67`	`+ SMILEI_PY_RELEASE_GIL`
	`68`	`+ return v;`
`45`	`69`	`}`
`46`	`70`	`double Function_Python3D::valueAt( vector<double> x_cell )`
`47`	`71`	`{`
`48`		`- return PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], x_cell[2] );`
	`72`	`+ SMILEI_PY_ACQUIRE_GIL`
	`73`	`+ double v = PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], x_cell[2] );`
	`74`	`+ SMILEI_PY_RELEASE_GIL`
	`75`	`+ return v;`
`49`	`76`	`}`
`50`	`77`	`// 3D complex`
`51`	`78`	`std::complex<double> Function_Python3D::complexValueAt( vector<double> x_cell, double time )`
`52`	`79`	`{`
`53`		`- return PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1], time );`
	`80`	`+ SMILEI_PY_ACQUIRE_GIL`
	`81`	`+ std::complex<double> v = PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1], time );`
	`82`	`+ SMILEI_PY_RELEASE_GIL`
	`83`	`+ return v;`
`54`	`84`	`}`
`55`	`85`
`56`	`86`	`// 4D`
`57`	`87`	`double Function_Python4D::valueAt( vector<double> x_cell, double time )`
`58`	`88`	`{`
`59`		`- return PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], x_cell[2], time );`
	`89`	`+ SMILEI_PY_ACQUIRE_GIL`
	`90`	`+ double v = PyTools::runPyFunction( py_profile, x_cell[0], x_cell[1], x_cell[2], time );`
	`91`	`+ SMILEI_PY_RELEASE_GIL`
	`92`	`+ return v;`
`60`	`93`	`}`
`61`	`94`	`// 4D complex`
`62`	`95`	`std::complex<double> Function_Python4D::complexValueAt( vector<double> x_cell, double time )`
`63`	`96`	`{`
`64`		`- return PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1], x_cell[2], time );`
	`97`	`+ SMILEI_PY_ACQUIRE_GIL`
	`98`	`+ std::complex<double> v = PyTools::runPyFunction<std::complex<double>>( py_profile, x_cell[0], x_cell[1], x_cell[2], time );`
	`99`	`+ SMILEI_PY_RELEASE_GIL`
	`100`	`+ return v;`
`65`	`101`	`}`
`66`	`102`
`67`	`103`	`// Special cases for locations specified in numpy arrays`
`68`	`104`	`#ifdef SMILEI_USE_NUMPY`
`69`	`105`	`PyArrayObject Function_Python1D::valueAt( std::vector<PyArrayObject > x )`
`70`	`106`	`{`
`71`		`- return ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], NULL );`
	`107`	`+ SMILEI_PY_ACQUIRE_GIL`
	`108`	`+ PyArrayObject * v = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], NULL );`
	`109`	`+ SMILEI_PY_RELEASE_GIL`
	`110`	`+ return v;`
`72`	`111`	`}`
`73`	`112`	`PyArrayObject Function_Python2D::valueAt( std::vector<PyArrayObject > x )`
`74`	`113`	`{`
`75`		`- return ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], NULL );`
	`114`	`+ SMILEI_PY_ACQUIRE_GIL`
	`115`	`+ PyArrayObject * v = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], NULL );`
	`116`	`+ SMILEI_PY_RELEASE_GIL`
	`117`	`+ return v;`
`76`	`118`	`}`
`77`	`119`	`PyArrayObject Function_Python3D::valueAt( std::vector<PyArrayObject > x )`
`78`	`120`	`{`
`79`		`- return ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], NULL );`
	`121`	`+ SMILEI_PY_ACQUIRE_GIL`
	`122`	`+ PyArrayObject * v = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], NULL );`
	`123`	`+ SMILEI_PY_RELEASE_GIL`
	`124`	`+ return v;`
`80`	`125`	`}`
`81`	`126`	`PyArrayObject Function_Python2D::complexValueAt( std::vector<PyArrayObject > x )`
`82`	`127`	`{`
	`128`	`+ SMILEI_PY_ACQUIRE_GIL`
`83`	`129`	`PyObject *values = PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], NULL );`
`84`	`130`	`PyArrayObject cvalues = ( PyArrayObject )PyObject_CallMethod( values, const_cast<char >("astype"), const_cast<char >("s"), const_cast<char *>("complex"), NULL );`
`85`	`131`	`Py_DECREF( values );`
	`132`	`+ SMILEI_PY_RELEASE_GIL`
`86`	`133`	`return cvalues;`
`87`	`134`	`}`
`88`	`135`
`89`	`136`	`// Time dependent`
`90`	`137`
`91`	`138`	`PyArrayObject Function_Python1D::valueAt( std::vector<PyArrayObject >, double time )`
`92`	`139`	`{`
	`140`	`+ SMILEI_PY_ACQUIRE_GIL`
`93`	`141`	`PyObject *t = PyFloat_FromDouble( time );`
`94`	`142`	`PyArrayObject * ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, t, NULL );`
`95`	`143`	`Py_DECREF( t );`
	`144`	`+ SMILEI_PY_RELEASE_GIL`
`96`	`145`	`return ret;`
`97`	`146`	`}`
`98`	`147`	`PyArrayObject Function_Python2D::valueAt( std::vector<PyArrayObject > x, double time )`
`99`	`148`	`{`
	`149`	`+ SMILEI_PY_ACQUIRE_GIL`
`100`	`150`	`PyObject *t = PyFloat_FromDouble( time );`
`101`	`151`	`PyArrayObject * ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], t, NULL );`
`102`	`152`	`Py_DECREF( t );`
	`153`	`+ SMILEI_PY_RELEASE_GIL`
`103`	`154`	`return ret;`
`104`	`155`	`}`
`105`	`156`	`PyArrayObject Function_Python3D::valueAt( std::vector<PyArrayObject > x, double time )`
`106`	`157`	`{`
	`158`	`+ SMILEI_PY_ACQUIRE_GIL`
`107`	`159`	`PyObject *t = PyFloat_FromDouble( time );`
`108`	`160`	`PyArrayObject * ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], t, NULL );`
`109`	`161`	`Py_DECREF( t );`
	`162`	`+ SMILEI_PY_RELEASE_GIL`
`110`	`163`	`return ret;`
`111`	`164`	`}`
`112`	`165`	`PyArrayObject Function_Python4D::valueAt( std::vector<PyArrayObject > x, double time )`
`113`	`166`	`{`
	`167`	`+ SMILEI_PY_ACQUIRE_GIL`
`114`	`168`	`PyObject *t = PyFloat_FromDouble( time );`
`115`	`169`	`PyArrayObject * ret = ( PyArrayObject * )PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], t, NULL );`
`116`	`170`	`Py_DECREF( t );`
	`171`	`+ SMILEI_PY_RELEASE_GIL`
`117`	`172`	`return ret;`
`118`	`173`	`}PyArrayObject Function_Python4D::complexValueAt( std::vector<PyArrayObject > x, double time )`
`119`	`174`	`{`
	`175`	`+ SMILEI_PY_ACQUIRE_GIL`
`120`	`176`	`PyObject *t = PyFloat_FromDouble( time );`
`121`	`177`	`PyObject * values = PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], t, NULL );`
`122`	`178`	`Py_DECREF( t );`
`123`	`179`	`PyArrayObject cvalues = ( PyArrayObject )PyObject_CallMethod( values, const_cast<char >("astype"), const_cast<char >("s"), const_cast<char *>("complex"), NULL );`
`124`	`180`	`Py_DECREF( values );`
	`181`	`+ SMILEI_PY_RELEASE_GIL`
`125`	`182`	`return cvalues;`
`126`	`183`	`}`
`127`	`184`	`PyArrayObject Function_Python4D::complexValueAt( std::vector<PyArrayObject > x, PyArrayObject *t )`
`128`	`185`	`{`
	`186`	`+ SMILEI_PY_ACQUIRE_GIL`
`129`	`187`	`PyObject *values = PyObject_CallFunctionObjArgs( py_profile, x[0], x[1], x[2], t, NULL );`
`130`	`188`	`PyArrayObject cvalues = ( PyArrayObject )PyObject_CallMethod( values, const_cast<char >("astype"), const_cast<char >("s"), const_cast<char *>("complex"), NULL );`
`131`	`189`	`Py_DECREF( values );`
	`190`	`+ SMILEI_PY_RELEASE_GIL`
`132`	`191`	`return cvalues;`
`133`	`192`	`}`
`134`	`193`