SCRIPTWITHONEFUNCTION_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py'), FunctionVal(DirectOperatorInNS)], fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variable interne une seule fonction de calcul nommée DirectOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variable only one function named DirectOperator"),
DifferentialIncrement = SIMP(statut="o", typ = "R", val_min=0, val_max=1, defaut=0.01, fr="Incrément de la perturbation dX pour calculer la dérivée, construite en multipliant X par l'incrément en évitant les valeurs nulles", ang="Increment of dX perturbation to calculate the derivative, build multiplying X by the increment avoiding null values"),
CenteredFiniteDifference = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Formulation centrée (1) ou décentrée (0) pour la méthode des différences finies", ang="Centered (1) or uncentered (0) formulation for the finite differences method"),
- EnableMultiProcessing = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0, fr="Calculs élémentaires effectués en séquentiel (0) ou en parallèle (1) dans la méthode des différences finies", ang="Elementary calculations done sequentially (0) or in parallel (1) in the finite differences method"),
+ EnableWiseParallelism = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0, fr="Calculs élémentaires effectués en séquentiel (0) ou en parallèle (1) dans la méthode des différences finies", ang="Elementary calculations done sequentially (0) or in parallel (1) in the finite differences method"),
NumberOfProcesses = SIMP(statut="f", typ = "I", val_min=0, defaut=0, fr="Nombre de processus parallèles, 0 pour un contrôle automatique", ang="Number of parallel processes, 0 for automatic control"),
),
SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
Accelerating numerical derivatives calculations by using a parallel mode
------------------------------------------------------------------------
-.. index:: single: EnableMultiProcessing
+.. index:: single: EnableWiseParallelism
.. index:: single: NumberOfProcesses
When setting an operator, as described in
Under some conditions (described right after), it is then possible to
accelerate the numerical derivatives calculations by using a parallel mode for
the finite differences approximation. When setting up an ADAO case, it is done
-by adding the optional keyword "*EnableMultiProcessing*", set to "1" or
+by adding the optional keyword "*EnableWiseParallelism*", set to "1" or
"*True*". This keyword is included in the "*SCRIPTWITHONEFUNCTION*" command in
the operator definition by graphical interface, or in the "*Parameters*"
accompanying the command "*OneFunction*" by textual interaface. By default,
-this parallel mode is disabled ("*EnableMultiProcessing=0*"). The parallel mode
+this parallel mode is disabled ("*EnableWiseParallelism=0*"). The parallel mode
will only use local resources (both multi-cores or multi-processors) of the
computer on which execution is running, requiring by default as many resources
as available. If necessary, one can reduce the available resources by limiting
.. [Jazwinski70] Jazwinski A. H., *Stochastic Processes and Filtering Theory*, Academic Press, 1970
-.. [Johnson08] Johnson S. G., *The NLopt nonlinear-optimization package*, http://ab-initio.mit.edu/nlopt
+.. [Johnson08] Johnson S. G., *The NLopt nonlinear-optimization package*, http://github.com/stevengj/nlopt
.. [Julier95] Julier S., Uhlmann J., Durrant-Whyte H., *A new approach for filtering nonlinear systems*, in: Proceedings of the 1995 American Control Conference, IEEE, 1995
case.setObservationOperator(
OneFunction = SomeOperator,
Parameters = {
- "EnableMultiProcessingInEvaluation":True,
+ "EnableParallelEvaluations":True,
"NumberOfProcesses":5,
},
)
.. note::
- .. index:: single: EnableMultiProcessingInEvaluation
+ .. index:: single: EnableParallelEvaluations
It can be useful to make sure that the evaluation of the operator is really
done in parallel, and for example that there is no forced use of a
parallelism acceleration, which would avoid a real parallel test. For this
purpose, it is recommended to systematically use the boolean special
- parameter "*EnableMultiProcessingInEvaluation*", exclusively reserved for
- this purpose, of the operator declaration command. The use of this
- parameter is illustrated in this example. It should not be used in any
- other case.
+ parameter "*EnableParallelEvaluations*", exclusively reserved for this
+ purpose, of the operator declaration command. The use of this parameter is
+ illustrated in this example.
Scipy, 1.6.0
MatplotLib, 3.3.4
Gnuplot, 1.8
- NLopt, 2.4.2
+ NLopt, 2.7.0
with **P** the state error covariance and *t* the discrete iterative time. In
this scheme, the analysis **(x,P)** is obtained by means of the "*correction*"
-by observing the "*prediction*" of the previous state. An another way to
-understand data assimilation in dynamics, in the space of measured states and
-measured observations, leads to the following representation of a sequential
-form of data assimilation:
+by observing the "*prediction*" of the previous state. Another way of
+understanding data assimilation in dynamics, by observing the states in the
+measurement space, is to represent the same sequential assimilation process as
+in the previous figure in the following form:
.. _schema_d_AD_sequentiel:
.. figure:: images/schema_temporel_sequentiel.png
"*Script*" keyword, the operator is of type "*Matrix*", "*OneFunction*" or
"*ThreeFunctions*" according to whether one of these variables is
positioned to "*True*". The control parameters of the adjoint numerical
- approximation, in the "*OneFunction*"case, can be given by a dictionary
+ approximation, in the "*OneFunction*" case, can be given by a dictionary
through the "*Parameters*" keyword. Potential entries of this dictionary
- are "*DifferentialIncrement*", "*CenteredFiniteDifference*" (similar to the
- one of graphical interface). If the operator requires some complementary
- fixed arguments in addition to the state :math:`\mathbf{x}`, they can be
- given through the variable "*ExtraArguments*" as a named parameters
- dictionary.
+ are "*DifferentialIncrement*", "*CenteredFiniteDifference*",
+ "*EnableWiseParallelism*", "*NumberOfProcesses*" (similar to the one of
+ graphical interface). If the operator requires some complementary fixed
+ arguments in addition to the state :math:`\mathbf{x}`, they can be given
+ through the variable "*ExtraArguments*" as a named parameters dictionary.
.. index:: single: Observation
.. index:: single: setObservation
and will be considered as a vector. The control parameters of the adjoint
numerical approximation, in the "*OneFunction*"case, can be given by a
dictionary through the "*Parameters*" keyword. Potential entries of this
- dictionary are "*DifferentialIncrement*", "*CenteredFiniteDifference*"
- (similar to the one of graphical interface). If the operator requires some
- complementary fixed arguments in addition to the state :math:`\mathbf{x}`,
- they can be given through the variable "*ExtraArguments*" as a named
- parameters dictionary.
+ dictionary are "*DifferentialIncrement*", "*CenteredFiniteDifference*",
+ "*EnableWiseParallelism*", "*NumberOfProcesses*" (similar to the one of
+ graphical interface). If the operator requires some complementary fixed
+ arguments in addition to the state :math:`\mathbf{x}`, they can be given
+ through the variable "*ExtraArguments*" as a named parameters dictionary.
Setting the calculation, outputs, etc.
++++++++++++++++++++++++++++++++++++++
Accélérer les calculs de dérivées numériques en utilisant un mode parallèle
---------------------------------------------------------------------------
-.. index:: single: EnableMultiProcessing
+.. index:: single: EnableWiseParallelism
.. index:: single: NumberOfProcesses
Lors de la définition d'un opérateur, comme décrit dans le chapitre des
Sous certaines conditions (décrites juste après), il est possible d'accélérer
les calculs de dérivées numériques en utilisant un mode parallèle pour
l'approximation par différences finies. Lors de la définition d'un cas ADAO,
-c'est effectué en ajoutant le mot-clé optionnel "*EnableMultiProcessing*", mis
+c'est effectué en ajoutant le mot-clé optionnel "*EnableWiseParallelism*", mis
à "*1*" ou à "*True*". Ce mot-clé est inclus à la commande
"*SCRIPTWITHONEFUNCTION*" dans la définition de l'opérateur par interface
graphique, ou aux "*Parameters*" accompagnant la commande "*OneFunction*" par
interface textuelle. Par défaut, ce mode parallèle est désactivé
-("*EnableMultiProcessing=0*"). Le mode parallèle utilise uniquement des
+("*EnableWiseParallelism=0*"). Le mode parallèle utilise uniquement des
ressources locales (à la fois multi-coeurs ou multi-processeurs) de
l'ordinateur sur lequel l'exécution est en train de se dérouler, demandant par
défaut autant de ressources que disponible. Si nécessaire, on peut réduire les
.. [Jazwinski70] Jazwinski A. H., *Stochastic Processes and Filtering Theory*, Academic Press, 1970
-.. [Johnson08] Johnson S. G., *The NLopt nonlinear-optimization package*, http://ab-initio.mit.edu/nlopt
+.. [Johnson08] Johnson S. G., *The NLopt nonlinear-optimization package*, http://github.com/stevengj/nlopt
.. [Julier95] Julier S., Uhlmann J., Durrant-Whyte H., *A new approach for filtering nonlinear systems*, in: Proceedings of the 1995 American Control Conference, IEEE, 1995
case.setObservationOperator(
OneFunction = SomeOperator,
Parameters = {
- "EnableMultiProcessingInEvaluation":True,
+ "EnableParallelEvaluations":True,
"NumberOfProcesses":5,
},
)
.. note::
- .. index:: single: EnableMultiProcessingInEvaluation
+ .. index:: single: EnableParallelEvaluations
Il peut être utile de s'assurer que l'évaluation de l'opérateur est
réalisée réellement en parallèle, et par exemple qu'il n'y a pas
d'utilisation forcée d'une accélération du parallélisme, qui éviterait
ainsi un véritable test parallèle. Pour cela, il est recommandé d'utiliser
systématiquement le paramètre booléen spécial
- "*EnableMultiProcessingInEvaluation*", exclusivement réservé à cet usage,
- de la commande de déclaration de l'opérateur. L'usage de ce paramètre est
- illustré dans l'exemple présent. Il n'est à utiliser dans aucun autre cas.
+ "*EnableParallelEvaluations*", exclusivement réservé à cet usage, de la
+ commande de déclaration de l'opérateur. L'usage de ce paramètre est
+ illustré dans l'exemple présent.
Scipy, 1.6.0
MatplotLib, 3.3.4
Gnuplot, 1.8
- NLopt, 2.4.2
+ NLopt, 2.7.0
avec **P** la covariance d'erreur d'état et *t* le temps itératif discret. Dans
ce schéma, l'analyse **(x,P)** est obtenue à travers la "*correction*" par
l'observation de la "*prévision*" de l'état précédent. Une autre manière de
-comprendre l'assimilation de données dynamique, dans l'espace des états mesurés
-et observations mesurées, consiste à représenter la démarche séquentielle
-d'assimilation sous la forme suivante :
+comprendre l'assimilation de données dynamique, en observant les états dans
+l'espace des mesures, consiste à représenter sous la forme suivante la même
+démarche séquentielle d'assimilation que dans la figure précédente :
.. _schema_d_AD_sequentiel:
.. figure:: images/schema_temporel_sequentiel.png
adjoint, dans le cas "*OneFunction*", peuvent être renseignés par un
dictionnaire dans "*Parameters*". Les entrées potentielles de ce
dictionnaire de paramètres sont "*DifferentialIncrement*",
- "*CenteredFiniteDifference*", "*EnableMultiProcessing*",
+ "*CenteredFiniteDifference*", "*EnableWiseParallelism*",
"*NumberOfProcesses*" (similaires à celles de l'interface graphique). Si
l'opérateur nécessite des paramètres fixes complémentaires en plus de
l'état :math:`\mathbf{x}`, ils peuvent être fournis par la variable
renseignés par un dictionnaire dans "*Parameters*". Les entrées
potentielles de ce dictionnaire de paramètres sont
"*DifferentialIncrement*", "*CenteredFiniteDifference*",
- "*EnableMultiProcessing*", "*NumberOfProcesses*" (similaires à celles de
+ "*EnableWiseParallelism*", "*NumberOfProcesses*" (similaires à celles de
l'interface graphique). Si l'opérateur nécessite des paramètres fixes
complémentaires en plus de l'état :math:`\mathbf{x}`, ils peuvent être
fournis par la variable "*ExtraArguments*" sous la forme d'un dictionnaire
__Parameters = {}
if (asDict is not None) and isinstance(asDict, dict):
__Parameters.update( asDict )
- # Priorité à EnableMultiProcessingInDerivatives=True
- if "EnableMultiProcessing" in __Parameters and __Parameters["EnableMultiProcessing"]:
- __Parameters["EnableMultiProcessingInDerivatives"] = True
- __Parameters["EnableMultiProcessingInEvaluation"] = False
- if "EnableMultiProcessingInDerivatives" not in __Parameters:
- __Parameters["EnableMultiProcessingInDerivatives"] = False
- if __Parameters["EnableMultiProcessingInDerivatives"]:
- __Parameters["EnableMultiProcessingInEvaluation"] = False
- if "EnableMultiProcessingInEvaluation" not in __Parameters:
- __Parameters["EnableMultiProcessingInEvaluation"] = False
+ # Deprecated parameters
+ __Parameters = self.__deprecateOpt(
+ collection = __Parameters,
+ oldn = "EnableMultiProcessing",
+ newn = "EnableWiseParallelism",
+ )
+ __Parameters = self.__deprecateOpt(
+ collection = __Parameters,
+ oldn = "EnableMultiProcessingInEvaluation",
+ newn = "EnableParallelEvaluations",
+ )
+ __Parameters = self.__deprecateOpt(
+ collection = __Parameters,
+ oldn = "EnableMultiProcessingInDerivatives",
+ newn = "EnableParallelDerivatives",
+ )
+ # Priorité à EnableParallelDerivatives=True
+ if "EnableWiseParallelism" in __Parameters and __Parameters["EnableWiseParallelism"]:
+ __Parameters["EnableParallelDerivatives"] = True
+ __Parameters["EnableParallelEvaluations"] = False
+ if "EnableParallelDerivatives" not in __Parameters:
+ __Parameters["EnableParallelDerivatives"] = False
+ if __Parameters["EnableParallelDerivatives"]:
+ __Parameters["EnableParallelEvaluations"] = False
+ if "EnableParallelEvaluations" not in __Parameters:
+ __Parameters["EnableParallelEvaluations"] = False
if "withIncrement" in __Parameters: # Temporaire
__Parameters["DifferentialIncrement"] = __Parameters["withIncrement"]
- # Le défaut est équivalent à "ReducedOverallRequirements"
- __reduceM, __avoidRC = True, True
+ #
+ __reduceM, __avoidRC = True, True # Défaut
if performancePrf is not None:
if performancePrf == "ReducedAmountOfCalculation":
__reduceM, __avoidRC = False, True
__reduceM, __avoidRC = True, False
elif performancePrf == "NoSavings":
__reduceM, __avoidRC = False, False
+ # "ReducedOverallRequirements" et tous les autres choix (y.c rien)
+ # sont équivalents au défaut
#
if asScript is not None:
__Matrix, __Function = None, None
avoidingRedundancy = __Function["withAvoidingRedundancy"],
toleranceInRedundancy = __Function["withToleranceInRedundancy"],
lengthOfRedundancy = __Function["withLengthOfRedundancy"],
- mpEnabled = __Function["EnableMultiProcessingInDerivatives"],
+ mpEnabled = __Function["EnableParallelDerivatives"],
mpWorkers = __Function["NumberOfProcesses"],
mfEnabled = __Function["withmfEnabled"],
)
avoidingRedundancy = __avoidRC,
inputAsMultiFunction = inputAsMF,
extraArguments = self.__extraArgs,
- enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] )
+ enableMultiProcess = __Parameters["EnableParallelEvaluations"] )
self.__FO["Tangent"] = Operator(
name = self.__name + "Tangent",
fromMethod = FDA.TangentOperator,
avoidingRedundancy = __avoidRC,
inputAsMultiFunction = inputAsMF,
extraArguments = self.__extraArgs,
- enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] )
+ enableMultiProcess = __Parameters["EnableParallelEvaluations"] )
self.__FO["Tangent"] = Operator(
name = self.__name + "Tangent",
fromMethod = __Function["Tangent"],
reducingMemoryUse = __reduceM,
avoidingRedundancy = __avoidRC,
inputAsMultiFunction = inputAsMF,
- enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] )
+ enableMultiProcess = __Parameters["EnableParallelEvaluations"] )
self.__FO["Tangent"] = Operator(
name = self.__name + "Tangent",
fromMatrix = __matrice,
"x.__str__() <==> str(x)"
return str(self.__FO)
+ def __deprecateOpt(self, collection: dict, oldn: str, newn: str):
+ if oldn in collection:
+ collection[newn] = collection[oldn]
+ del collection[oldn]
+ __msg = "the parameter \"%s\" used in this case is"%(oldn,)
+ __msg += " deprecated and has to be replaced by \"%s\"."%(newn,)
+ __msg += " Please update your code."
+ warnings.warn(__msg, FutureWarning, stacklevel=50)
+ return collection
+
# ==============================================================================
class Algorithm(object):
"""
def _initialize(self, __multilines):
"Permet des pré-conversions automatiques simples de commandes ou clés"
__translation = {
- "Study_name" : "StudyName", # noqa: E203
- "Study_repertory" : "StudyRepertory", # noqa: E203
- "MaximumNumberOfSteps": "MaximumNumberOfIterations",
- "FunctionDict" : "ScriptWithSwitch", # noqa: E203
- "FUNCTIONDICT_FILE" : "SCRIPTWITHSWITCH_FILE", # noqa: E203
+ "Study_name" : "StudyName", # noqa: E203
+ "Study_repertory" : "StudyRepertory", # noqa: E203
+ "MaximumNumberOfSteps" : "MaximumNumberOfIterations", # noqa: E203
+ "EnableMultiProcessing": "EnableWiseParallelism",
+ "FunctionDict" : "ScriptWithSwitch", # noqa: E203
+ "FUNCTIONDICT_FILE" : "SCRIPTWITHSWITCH_FILE", # noqa: E203
}
for k, v in __translation.items():
__multilines = __multilines.replace(k, v)
self.text_da += data_name + "_ScriptWithOneFunction['DifferentialIncrement'] = " + str(float(self.dictMCVal[search_type + "SCRIPTWITHONEFUNCTION_DATA__DifferentialIncrement"])) + "\n"
self.text_da += data_name + "_ScriptWithOneFunction['CenteredFiniteDifference'] = " + str(self.dictMCVal[search_type + "SCRIPTWITHONEFUNCTION_DATA__CenteredFiniteDifference"]) + "\n"
if search_type + "SCRIPTWITHONEFUNCTION_DATA__EnableMultiProcessing" in self.dictMCVal.keys():
- self.text_da += data_name + "_ScriptWithOneFunction['EnableMultiProcessing'] = " + str(self.dictMCVal[search_type + "SCRIPTWITHONEFUNCTION_DATA__EnableMultiProcessing"]) + "\n"
+ self.text_da += data_name + "_ScriptWithOneFunction['EnableWiseParallelism'] = " + str(self.dictMCVal[search_type + "SCRIPTWITHONEFUNCTION_DATA__EnableMultiProcessing"]) + "\n"
+ if search_type + "SCRIPTWITHONEFUNCTION_DATA__EnableWiseParallelism" in self.dictMCVal.keys():
+ self.text_da += data_name + "_ScriptWithOneFunction['EnableWiseParallelism'] = " + str(self.dictMCVal[search_type + "SCRIPTWITHONEFUNCTION_DATA__EnableWiseParallelism"]) + "\n"
if search_type + "SCRIPTWITHONEFUNCTION_DATA__NumberOfProcesses" in self.dictMCVal.keys():
self.text_da += data_name + "_ScriptWithOneFunction['NumberOfProcesses'] = " + str(self.dictMCVal[search_type + "SCRIPTWITHONEFUNCTION_DATA__NumberOfProcesses"]) + "\n"
self.text_da += data_name + "_config = {}\n"
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "FunctionDict", "ScriptWithSwitch", fsrc )
fsrc = re.sub( "FUNCTIONDICT_FILE", "SCRIPTWITHSWITCH_FILE", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "FunctionDict", "ScriptWithSwitch", fsrc )
fsrc = re.sub( "FUNCTIONDICT_FILE", "SCRIPTWITHSWITCH_FILE", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "FunctionDict", "ScriptWithSwitch", fsrc )
fsrc = re.sub( "FUNCTIONDICT_FILE", "SCRIPTWITHSWITCH_FILE", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
fsrc = re.sub( "#CHECKSUM.*FIN CHECKSUM", "", fsrc )
#
# ==========================================================================
fsrc = jdc.getSource()
fsrc = re.sub( "MaximumNumberOfSteps", "MaximumNumberOfIterations", fsrc )
+ fsrc = re.sub( "EnableMultiProcessing", "EnableWiseParallelism", fsrc )
fsrc = re.sub( "FunctionDict", "ScriptWithSwitch", fsrc )
fsrc = re.sub( "FUNCTIONDICT_FILE", "SCRIPTWITHSWITCH_FILE", fsrc )
fsrc = re.sub( "#VERSION_CATALOGUE:.*:FIN VERSION_CATALOGUE", "#VERSION_CATALOGUE:%s:FIN VERSION_CATALOGUE"%version_out, fsrc)
node_script += """ centeredDF = %s,\n"""%str(ScriptWithOneFunction['CenteredFiniteDifference'])
if 'EnableMultiProcessing' in list(ScriptWithOneFunction.keys()):
node_script += """ mpEnabled = %s,\n"""%str(ScriptWithOneFunction['EnableMultiProcessing'])
+ if 'EnableWiseParallelism' in list(ScriptWithOneFunction.keys()):
+ node_script += """ mpEnabled = %s,\n"""%str(ScriptWithOneFunction['EnableWiseParallelism'])
if 'NumberOfProcesses' in list(ScriptWithOneFunction.keys()):
node_script += """ mpWorkers = %s,\n"""%str(ScriptWithOneFunction['NumberOfProcesses'])
node_script += """ )\n"""
node_script += """ centeredDF = %s,\n"""%str(ScriptWithOneFunction['CenteredFiniteDifference'])
if 'EnableMultiProcessing' in list(ScriptWithOneFunction.keys()):
node_script += """ mpEnabled = %s,\n"""%str(ScriptWithOneFunction['EnableMultiProcessing'])
+ if 'EnableWiseParallelism' in list(ScriptWithOneFunction.keys()):
+ node_script += """ mpEnabled = %s,\n"""%str(ScriptWithOneFunction['EnableWiseParallelism'])
if 'NumberOfProcesses' in list(ScriptWithOneFunction.keys()):
node_script += """ mpWorkers = %s,\n"""%str(ScriptWithOneFunction['NumberOfProcesses'])
node_script += """ )\n"""
