| Structures |
|---|
Name: Libnuceq__SpeciesDescription: Libnuceq__Species is a structure that stores information about a species in an equilibrium calculation. |
Name: LibnuceqDescription: Libnuceq is a structure that stores information for an equilibrium calculation. |
Name: Libnuceq__ClusterDescription: Libnuceq__Cluster is a structure that stores information about an equilibrium cluster, that is, a subset of nuclei in an equilibrium that are in equilibrium with each other. |
| User-Supplied Routines |
|---|
Name: Libnuceq__Cluster__iterateFunction()Description: User-supplied routine to be applied during an iteration over the clusters in an equilibrium. Syntax:
int
Libnucnet__Cluster__iterateFunction(
Libnuceq__Cluster *self,
void *p_data
);
Input:
User's routine must return 1 to continue or 0 to stop. |
Name: Libnuceq__Cluster_constraint_function()Description: User-supplied routine to compute the contribution of a species to a constraint on a cluster. Syntax:
double
Libnuceq__Cluster_constraint_function(
Libnuceq__Species *p_species,
void *p_data
);
Input:
User's routine must return the contribution of the input species to the cluster constraint. |
Name: Libnuceq__Cluster_prefactor_function()Description: User-supplied routine to compute the contribution of a species to the prefactor of an equilibrium cluster. Syntax:
double
Libnuceq__Cluster_prefactor_function(
Libnuceq__Cluster *p_cluster,
Libnuceq__Species *p_species,
void *p_data
);
Input:
User's routine must return the contribution to the cluster prefactor. |
Name: Libnuceq__Species__iterateFunction()Description: User-supplied routine to be applied during an iteration over an equilibrium. Syntax:
int
Libnucnet__Species__iterateFunction(
Libnuceq__Species *self,
void *p_data
);
Input:
User's routine must return 1 to continue or 0 to stop. |
Name: Libnuceq__wseCorrectionFunction()Description: User-supplied routine to compute the extra addend to the weak statistical equilibrium relation between neutrons, protons, and electrons. This function is equal to mu_p/kT + mu_e/kT - mu_n/kT in weak statistical equilibrium. Syntax:
double
Libnuceq__wseCorrectionFunction(
Libnuceq *self,
void *p_data
);
Input:
User's routine must return the addend to the weak equilibrium relation. |
| Routines |
|---|
Name: Libnuceq__Cluster__free()Description: Free a Libnuceq cluster. Syntax:
void
Libnuceq__Cluster__free(
Libnuceq__Cluster *self
);
Input:
On successful return, the cluster has been freed. Example: Free the cluster Libnuceq__Cluster *p_my_cluster:
Libnuceq__Cluster__free(
p_my_cluster
);
|
Name: Libnuceq__Cluster__getConstraint()Description: Retrieve the abundance constraint for a cluster. Syntax:
double
Libnuceq__Cluster__getConstraint(
const Libnuceq__Cluster *self
);
Input:
The routine returns a double giving the abundance constraint on a Cluster. If the input structure is not valid, Libnuceq error handling is invoked. Example: Print the constraint for p_my_cluster:
printf(
"Cluster constraint is %g\n",
Libnuceq__Cluster__getConstraint( p_my_cluster )
);
|
Name: Libnuceq__Cluster__getMukT()Description: Retrieve the chemical potential of an equilibrium cluster. Syntax:
double
Libnuceq__Cluster__getMukT(
const Libnuceq__Cluster *self
);
Input:
The routine returns the chemical potential divided by kT for the equilibrium cluster. If the input equilibrium cluster is invalid, Libnuceq error handling is invoked. Example: Print the chemical potential (divided by kT) for the cluster p_my_cluster:
fprintf(
stdout,
"The mu / kT for the equilibrium cluster is %g.\n",
Libnuceq__Cluster__getMukT( p_my_equil )
);
|
Name: Libnuceq__Cluster__getNumberOfSpecies()Description: Retrieve the number of species in an equilibrium cluster. Syntax:
size_t
Libnuceq__Cluster__getNumberOfSpecies(
const Libnuceq__Cluster *self
);
Input:
Routine returns the number of species in the equilibrium cluster. If the input structure is not valid, Libnuceq error handling is invoked. Example: Print the number of species in the cluster defined by nuclei with Z >= 6 in equilibrium p_my_equil:
p_cluster = Libnuceq__getCluster( p_my_equil, "[z >= 6]" );
printf(
"The number of species in the equilibrium cluster is %lu:\n"
(unsigned long) Libnuceq__Cluster__getNumberOfSpecies( p_cluster )
);
|
Name: Libnuceq__Cluster__getXPathString()Description: Retrieve the XPath string defining a cluster. Syntax:
const char *
Libnuceq__Cluster__getXPathString(
const Libnuceq__Cluster *self
);
Input:
The routine returns the string defining the input cluster. If the input structure is not valid, Libnuceq error handling is invoked. Example: Print the XPath string for p_my_cluster:
printf(
"Cluster XPath is %s\n",
Libnuceq__Cluster__getXPathString( p_my_cluster )
);
|
Name: Libnuceq__Cluster__iterateSpecies()Description: Iterate over the species in an equilibrium cluster and apply the user-supplied function. Syntax:
void
Libnuceq__Cluster__iterateSpecies(
const Libnuceq__Cluster *self,
(Libnuceq__Species__iterateFunction) pf_my_function,
void *p_data
);
Input:
The routine iterates through the species in the equilibrium cluster and applies the user-supplied routine to each species. If any input is invalid, error handling is invoked. Example: Iterate through the species in p_my_cluster and apply the function my_iterate_function and the extra data p_user_data:
Libnuceq__Cluster__iterateSpecies(
p_my_cluster,
(Libnuceq__Species__iterateFunction) my_iterate_function,
p_user_data
);
|
Name: Libnuceq__Cluster__updateConstraint()Description: Update the abundance constraint for a cluster. Syntax:
void
Libnuceq__Cluster__updateConstraint(
Libnuceq__Cluster *self,
double d_constraint
);
Input:
On successful return, the abundance constraint on a cluster has been updated. If the input structure is not valid, Libnuceq error handling is invoked. Example: Update the constraint for p_my_cluster to 0.01:
Libnuceq__Cluster__updateConstraint(
p_my_cluster,
0.01
);
|
Name: Libnuceq__Cluster__updateConstraintFunction()Description: Update the constraint function for a cluster and its associated data. Syntax:
void
Libnuceq__Cluster__updateConstraintFunction(
Libnuceq__Cluster *self,
Libnuceq__Cluster__constraint_function pf_func,
void *p_data
);
Input:
On successful return, the cluster's constraint function and associated data have been updated. If the input structure is not valid, Libnuceq error handling is invoked. Example: Update Libnucnet__Cluster *p_my_cluster with the constraint function pf_my_func and associated data *p_data:
Libnuceq__Cluster__updateConstraintFunction(
p_my_cluster,
(Libnuceq__Cluster__constraint_function) pf_my_func,
p_data
);
|
Name: Libnuceq__Cluster__updatePrefactorFunction()Description: Update the prefactor function for a cluster and its associated data. Syntax:
void
Libnuceq__Cluster__updatePrefactorFunction(
Libnuceq__Cluster *self,
Libnuceq__Cluster__prefactorFunction pf_func,
void *p_data
);
Input:
On successful return, the cluster's prefactor function and associated data have been updated. If the input structure is not valid, Libnuceq error handling is invoked. Example: Update Libnucnet__Cluster *p_my_cluster with the prefactor function pf_my_func and associated data *p_data:
Libnuceq__Cluster__updatePrefactorFunction(
p_my_cluster,
(Libnuceq__Cluster__prefactorFunction) pf_my_func,
p_data
);
|
Name: Libnuceq__Species__getAbundance()Description: Retrieve the equilibrium abundance of a species. Syntax:
double
Libnuceq__Species__getAbundance(
Libnuceq__Species *self
);
Input:
Routine returns a double giving the abundance of the species. If the input species is not valid, Libnuceq error handling is invoked. Example: Print the abundance of ni56 in the equilibrium p_my_equil:
fprintf(
stdout,
"Abundance of ni56 is %g.\n",
Libnuceq__Species__getAbundance(
Libnuceq__getSpeciesByName(
p_my_equil,
"ni56"
)
);
|
Name: Libnuceq__Species__getNucSpecies()Description: Return the Libnucnet__Nuc species corresponding to the given species in the equilibrium structure. Syntax:
Libnucnet__Species *
Libnuceq__Species__getNucSpecies( Libnuceq__Species *self );
Input:
The routine returns a pointer to the underlying Libnucnet__Species structure. If the input structure is not valid, Libnuceq error handling is invoked. Example: Print the mass excess of Libnuceq__Species *p_eq_species:
fprintf(
stdout,
"The mass excess of %s is %g (MeV).\n",
Libnucnet__Species__getName(
Libnuceq__Species__getNucSpecies( p_eq_species )
),
Libnucneq__Species__getMassExcess(
Libnuceq__Species__getNucSpecies( p_eq_species )
)
);
|
Name: Libnuceq__clearNseCorrectionFactorFunction()Description: Clear the NSE correction factor function and the associated data for the equilibrium. Syntax:
void
Libnuceq__clearNseCorrectionFactorFunction(
Libnuceq *self
);
Input:
On successful return, the correction factor function has been reset to the default (no correction). If the input equilibrium is not valid, Libnuceq error handling is invoked. Example: For equilibrium p_my_equil, clear the correction factor function:
Libnuceq__clearNseCorrectionFactorFunction(
p_my_equil
);
|
Name: Libnuceq__clearYe()Description: Clear the Ye constraint for an equilibrium. Syntax:
void
Libnuceq__clearYe( Libnuceq *self );
Input:
On successful return, the Ye constraint for the equilibrium has been removed. If the input structure is not valid, Libnuceq error handling is invoked. Example: Clear the Ye constraint on p_my_equil:
Libnucnet__clearYe(
p_my_equil
);
|
Name: Libnuceq__computeAMoment()Description: Compute the moment of the abundances of the equilibrium about the mass number of each species raised to a power. Syntax:
double
Libnuceq__computeAMoment(
const Libnuceq *self,
unsigned int i
);
Input:
Routine returns the sum of the abundance of each species times the species mass number raised to the power i. If the input equilibrium is not valid, Libnuceq error handling is invoked. Examples: Print the sum of abundances for the equilibrium p_my_equil:
fprintf(
stdout,
"Sum of abundances = %e\n",
Libnuceq__computeAMoment( p_my_equil, 0 )
);
Print the sum of mass fractions for the equilibrium p_my_equil:
fprintf(
stdout,
"Sum of mass fractions = %e\n",
Libnuceq__computeAMoment( p_my_equil, 1 )
);
|
Name: Libnuceq__computeEquilibrium()Description: Compute the equilibrium for the input temperature and density. Syntax:
void
Libnuceq__computeEquilibrium(
Libnuceq *self
double d_t9,
double d_rho
);
Input:
On successful return, the equilibrium has been computed. Equilibrium abundances and chemical potentials may be retrieved with other API routines. If the input is invalid, Libnuceq error handling is invoked. Example: Compute the equilibrium for the input structure p_my_equil at a temperature of 5 billion K and 1.e7 g/cc:
Libnuceq__computeEquilibrium(
p_my_equil,
5.,
1.e7
);
|
Name: Libnuceq__computeZMoment()Description: Compute the moment of the abundances of the equilibrium about the charge of each species raised to a power. Syntax:
double
Libnuceq__computeZMoment(
const Libnuceq *self,
unsigned int i
);
Input:
Routine returns the sum of the abundance of each species times the species charge raised to the power i. If the input equilibrium is not valid, Libnuceq error handling is invoked. Example: Print Ye for the equilibrium p_my_equil:
fprintf(
stdout,
"Ye = %e\n",
Libnuceq__computeZMoment( p_my_equil, 1 )
);
|
Name: Libnuceq__copy_clusters()Description: Copy the clusters from one equilibrium to another. Syntax:
void
Libnuceq__copy_clusters(
Libnuceq * destination, Libnuceq * source
);
Input:
On successful return, the clusters in the source equilibrium have been copied to the destination. Before copying, the routine first clears any clusters in the destination equilibrium. If the source or destination structure is not valid, or if the source and destination structures do not share the same parent nuclear collection, Libnuceq error handling is invoked. Example: Copy the equilibrium clusters from equilibrium p_source to p_destination.
Libnuceq__copy_clusters( p_destination, p_source );
|
Name: Libnuceq__free()Description: Free a Libnuceq structure. Syntax:
void Libnucnet__free( Libnuceq *self );
Input:
On successful return, the Libnuceq structure memory has been freed. Example: Free the memory for Libnuceq *p_my_eq:
Libnuceq__free( p_my_eq );
|
Name: Libnuceq__getAbundances()Description: Retrieve the abundances of the species in an equilibrium. Syntax:
gsl_vector *
Libnuceq__getAbundances(
const Libnuceq__Cluster *self
);
Input:
Routine returns a new gsl_vector containing the abundances in the equilibrium. The species are sorted according to the sorting set for the underlying Libnucnet__Nuc structure. If the input structure is not valid, Libnuceq error handling is invoked. Example: Retrieve the abundances from the equilibrium p_my_equil and store them in the new gsl_vector p_my_abundances:
p_my_abundances =
Libnuceq__getAbundances( p_my_equil );
|
Name: Libnuceq__getCluster()Description: Retrieve a cluster from an equilibrium structure. Syntax:
Libnucnet__Cluster *
Libnuceq__getCluster(
Libnuceq *self,
const char *s_xpath
);
Input:
The routine returns a pointer to the cluster. If the input structure is not valid, Libnuceq error handling is invoked. If the cluster is not found, routine returns NULL. Example: Retrieve the pointer to the Libnuceq__Cluster *p_my_cluster from Libnuceq *p_my_equil that was defined by the XPath expression "[z >= 6]";
p_my_cluster
Libnuceq__getCluster(
p_my_equil,
"[z >= 6]"
);
|
Name: Libnuceq__getMuekT()Description: Retrieve the electron chemical potential from an equilibrium. Syntax:
double
Libnuceq__getMuekT(
const Libnuceq *self
);
Input:
The routine returns the electron chemical potential divided by kT for the equilibrium. If the input equilibrium is invalid, Libnuceq error handling is invoked. Example: Print the electron chemical potential (divided by kT) for p_my_equil:
fprintf(
stdout,
"The mu_e / kT for the equilibrium is %g.\n",
Libnuceq__getMuekT( p_my_equil )
);
|
Name: Libnuceq__getMunkT()Description: Retrieve the neutron chemical potential from an equilibrium. Syntax:
double
Libnuceq__getMunkT(
const Libnuceq *self
);
Input:
The routine returns the neutron chemical potential divided by kT for the equilibrium. If the input equilibrium is invalid, Libnuceq error handling is invoked. Example: Print the neutron chemical potential (divided by kT) for p_my_equil:
fprintf(
stdout,
"The mu_n / kT for the equilibrium is %g.\n",
Libnuceq__getMunkT( p_my_equil )
);
|
Name: Libnuceq__getMupkT()Description: Retrieve the proton chemical potential from an equilibrium. Syntax:
double
Libnuceq__getMupkT(
const Libnuceq *self
);
Input:
The routine returns the proton chemical potential divided by kT for the equilibrium. If the input equilibrium is invalid, Libnuceq error handling is invoked. Example: Print the proton chemical potential (divided by kT) for p_my_equil:
fprintf(
stdout,
"The mu_p / kT for the equilibrium is %g.\n",
Libnuceq__getMupkT( p_my_equil )
);
|
Name: Libnuceq__getNuc()Description: Return the Libnucnet__Nuc nuclear collection underlying the equilibrium structure. Syntax:
Libnucnet__Nuc *
Libnuceq__getNuc( Libnuceq *self );
Input:
The routine returns a pointer to the underlying nuclear collection. If the input structure is not valid, Libnuceq error handling is invoked. Example: Retrieve the pointer to the Libnucnet__Nuc structure underlying Libnuceq *p_my_equil and call it p_my_nuclei:
p_my_nuclei =
Libnuceq__getNuc(
p_my_equil
);
|
Name: Libnuceq__getNumberOfClusters()Description: Retrieve the current number of clusters in the equilibrium. Syntax:
size_t
Libnuceq__getNumberOfClusters(
const Libnuceq__Cluster *self
);
Input:
The routine returns the number of clusters currently set for the equilibrium. Example: Print the number of clusters in the equilibrum p_equil:
printf(
"The equilibrium has %lu clusters.\n",
(unsigned long) Libnuceq__getNumberOfClusters( p_equil )
);
|
Name: Libnuceq__getNumberOfSpecies()Description: Retrieve the number of species in an equilibrium. Syntax:
size_t
Libnuceq__getNumberOfSpecies(
const Libnuceq *self
);
Input:
Routine returns the number of species in the equilibrium. If the input structure is not valid, Libnuceq error handling is invoked. Example: Print the number of species in equilibrium p_my_equil:
printf(
"The number of species in the equilibrium is %lu:\n"
(unsigned long) Libnuceq__getNumberOfSpecies( p_my_equil )
);
|
Name: Libnuceq__getRho()Description: Retrieve the density (in g/cc) at which an equilibrium was computed. Syntax:
double
Libnuceq__getRho(
const Libnuceq *self
);
Input:
The routine returns a double giving the density at which the equilibrium was computed. If the input structure is not valid, Libnuceq error handling is invoked. If the equilibrium has not yet been computed, the routine returns zero. Example: Retrieve the density at which the equilibrium p_my_equil was computed:
d_rho = Libnuceq__getRho( p_my_equil );
if( d_rho )
printf(
"Equilibrium computed at rho = %g g/cc\n",
d_rho
);
else
printf( "Equilibrium not yet computed.\n" );
|
Name: Libnuceq__getSpeciesByName()Description: Retrieve a species by its name from an equilibrium structure. Syntax:
Libnuceq__Species *
Libnuceq__getSpeciesByName(
Libnuceq *self,
const char *s_name
);
Input:
Routine returns a pointer to the species. If the species does not exist in the equilibrium, routine returns NULL. If the input structure is not valid, Libnuceq error handling is invoked. Example: Retrieve the pointer to the Libnuceq__Species *p_eq_species for ni56 from equilibrium p_my_equil:
p_eq_species =
Libnuceq__getSpeciesByName(
p_my_equil,
"ni56"
);
|
Name: Libnuceq__getT9()Description: Retrieve the temperature (in billions of K) at which an equilibrium was computed. Syntax:
double
Libnuceq__getT9(
const Libnuceq *self
);
Input:
The routine returns a double giving the temperature at which the equilibrium was computed. If the input structure is not valid, Libnuceq error handling is invoked. If the equilibrium has not yet been computed, the routine returns zero. Example: Retrieve the temperature at which the equilibrium p_my_equil was computed:
d_t9 = Libnuceq__getT9( p_my_equil );
if( d_t9 )
printf(
"Equilibrium computed at T9 = %g\n",
d_t9
);
else
printf( "Equilibrium not yet computed.\n" );
|
Name: Libnuceq__iterateClusters()Description: Iterate the clusters in an equilibrium and apply the user-defined function and associated data. Syntax:
void
Libnuceq__iterateClusters(
Libnuceq *self,
Libnuceq__Cluster__iterateFunction pf_func,
void *p_data
);
Input:
Routine iterates over the clusters in the equilibrium and applies the user-supplied function and data. If any input is not valid, Libnuceq error handling is invoked. Example: Iterate over the clusters in the equilibrium p_my_equil and apply the function p_my_cluster_function and the data structure p_my_data.
Libnuceq__iterateClusters(
p_my_equil,
(Libnuceq__Cluster__iterateFunction) pf_my_cluster_function,
p_data
);
|
Name: Libnuceq__iterateSpecies()Description: Iterate over the species in an equilibrium and apply the user-supplied function. Syntax:
void
Libnuceq__iterateSpecies(
const Libnuceq *self,
(Libnuceq__Species__iterateFunction) pf_my_function,
void *p_data
);
Input:
The routine iterates through the species in the equilibrium and applies the user-supplied routine to each species. If any input is invalid, error handling is invoked. Example: Iterate through the species in p_my_equilibrium and apply the function my_iterate_function and the extra data p_user_data:
Libnuceq__iterateSpecies(
p_my_equil,
(Libnuceq__Species__iterateFunction) my_iterate_function,
p_user_data
);
|
Name: Libnuceq__new()Description: Create a new Libnuceq structure. Syntax:
Libnuceq *
Libnuceq__new( Libnucnet__Nuc *p_nuc );
Input:
The routine returns a pointer to a new Libnuceq structure. If it is not possible to allocate memory for the new structure, Libnuceq error handling is invoked. Example: Create a Libnuceq structure p_my_eq from the Libnucnet__Nuc structure p_my_nuclei:
p_my_eq =
Libnuceq__new(
p_my_nuclei
);
|
Name: Libnuceq__newCluster()Description: Create a new Libnuceq cluster. Syntax:
Libnuceq__Cluster *
Libnuceq__newCluster(
Libnuceq *self,
const char *s_xpath
);
Input:
The routine returns a pointer to a new Libnuceq__Cluster structure. If it is not possible to allocate memory for the new structure, Libnuceq error handling is invoked. Example: Create a new equilibrium cluster within the equilibrium p_my_equil for all nuclei with charge greater than or equal to 6:
p_my_cluster =
Libnuceq__newCluster(
p_my_equil,
"[z >= 6]"
);
|
Name: Libnuceq__removeCluster()Description: Remove a cluster from an equilibrium. Syntax:
int
Libnuceq__removeCluster(
Libnuceq *self,
Libnuceq__Cluster *p_cluster
);
Input:
Routine returns 1 (true) if the removal succeeded and 0 (false) if not. If the input is invalid, Libnuceq error handling is invoked. Example: Remove the cluster containing all nuclear with atomic number Z = 12 from the equilibrium p_my_equil:
p_cluster =
Libnuceq__getCluster(
p_my_equil,
"[z = 12]"
);
if( !Libnuceq__removeCluster( p_my_equil, p_cluster ) )
fprintf(
stderr,
"Couldn't remove cluster!\n"
);
|
Name: Libnuceq__setNseCorrectionFactorFunction()Description: Set the NSE correction factor function and the associated data for the equilibrium. Syntax:
void
Libnuceq__setNseCorrectionFactorFunction(
Libnuceq *self,
Libnucnet__Species__nseCorrectionFactorFunction pf_func,
void *p_data
);
Input:
On successful return, the correction factor function and the associated data have been set to the input values. If any input is not valid, Libnuceq error handling is invoked. Example: For equilibrium p_my_equil, set the correction factor function to my_correction_function and set the associated data to point to the data structure my_data:
Libnuceq__setNseCorrectionFactorFunction(
p_my_equil,
(Libnucnet__Species__nseCorrectionFactorFunction) my_correction_function,
p_data
);
|
Name: Libnuceq__setYe()Description: Set the Ye constraint for an equilibrium. Syntax:
void
Libnuceq__setYe( Libnuceq *self, double d_ye );
Input:
On successful return, the Ye constraint for the equilibrium has been set. If a previous Ye constraint existed, it has been replaced with the new value. If the input structure is not valid, or the Ye is not valid, Libnuceq error handling is invoked. Example: Set the Ye constraint on p_my_equil to 0.43:
Libnucnet__setYe(
p_my_equil, 0.43
);
|
Name: Libnuceq__updateUserElectronNumberDensity()Description: Set the function and integrand and associated data for computing the electron number density from its corresponding chemical potential in an equilibrium to the user-supplied values. Syntax:
void
Libnuceq__updateUserElectronNumberDensity(
Libnuceq *self,
Libstatmech__Fermion__Function pf_func,
Libstatmech__Fermion__Integrand pf_integrand,
void *p_function_data,
void *p_integrand_data
);
Input:
On successful return the number density function and integrand for the electrons has been set to the input values along with the extra data. If both the function and integrand are NULL, the default (non-interacting relativistic electrons) is used. If the either function or integrand is not NULL, it is used in place of the default. If the input structure is not valid, Libnuceq error handling is invoked. Example: Set the number density function for electrons to the user-supplied function my_function that uses extra data in my_data and do not use an integrand:
Libnuceq__updateUserElectronNumberDensityFunction(
p_my_equil,
(Libstatmech__Fermion__function) my_function,
NULL,
&my_data,
NULL
);
|
Name: Libnuceq__updateWseCorrectionFunction()Description: Update the WSE relation correction function and its associated data. Syntax:
void
Libnuceq__updateWseCorrectionFunction(
Libnuceq *self,
Libnuceq__wseCorrectionFunction pf_func,
void *p_data
);
Input:
On successful return, the wse correction function and associated data have been updated. If the input structure is not valid, Libnuceq error handling is invoked. Example: Update Libnucnet *p_my_equilibrium with the wse correction function pf_my_func and associated data *p_data:
Libnuceq__updateWseCorrectionFunction(
p_my_equilibrium,
(Libnuceq__wseCorrectionFunction) pf_my_func,
p_data
);
|