Recent changes to Advanced

Advanced modified by Benoit CLEMENT

Benoit CLEMENT — Sun, 20 Apr 2014 06:52:47 -0000

--- v8
+++ v9
@@ -6,6 +6,12 @@
 If you have a plug-in that you would like to see integrated in the standard STARucn release, please contact the authors.

 [TOC]
+
+## Adding a new class
+To add a new class into STARucn, you just need to copy the header (`.h`) file into `inc/plugins` and the source code (`.cpp`) in `src/plugins`.
+Plug-ins are classes inheriting from one of the four base classes: `BaseGenerator`, `BasePropagator`, `BaseInteraction`, `BaseOutputInterface`.
+
+To finalize the integration of your new class, you just need to clean and recompile the code calling `make clean all`. Your new plug-in can now be used from the main STARucn script.

 ## Script interface
 The interface between the code and the parameters file is done through the [`ParameterReader`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/ParameterReader.h) class.

Advanced modified by Benoit CLEMENT

Benoit CLEMENT — Sat, 19 Apr 2014 12:17:08 -0000

--- v7
+++ v8
@@ -1,7 +1,9 @@
 Advanced user manual

 This part of the manual describe how advanced users can implement their own plug-ins.
-If you have a plug-in that you would like to see integrated in the standard STARucn release, please contact the author.
+In addition to the information here, we strongly suggest anyone who wants to write a STARucn plug-in to look directly at the source code of the existing ones.
+
+If you have a plug-in that you would like to see integrated in the standard STARucn release, please contact the authors.

 [TOC]

@@ -53,6 +55,13 @@
 * `static void ParameterReader::ReadString(std::vector&, std::string, char = '|')`: decompose a string into a vector of substrings, eg. "a|b|c" -> {"a","b","c"}. The third parameter defines the substring separator within the initial string.
 * `static std::string ParameterReader::Substitute(std::string, char, char)` : substitute a char by another in a string

+## Useful classes
+### `Particle` class
+see [header file](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/Particle.h)
+
+### `Geometry` class 
+see [header file](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/Geometry.h)
+

 ## Plug-ins

@@ -85,40 +94,45 @@
 In addition a third method can be overriden, `virtual bool Good()`, that test the status of the generator. The simulation will stop at the generation step if it return `false`. By default, this method always return `true`.  

 A random number generator can be accessed from within the class via the `static TRandom3  Gen` private member. It is initialized with the `int GenerationSeed` parameter from the main simulation script (see user manual).
- 
+
+
 ### Propagator
 The propagator plug-in inherits from the [`BasePropagator`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BasePropagator.h) class.
+The mandatory virtual methods are:

-* `virtual bool   Propagate(double dt, Particle&)`
-* `virtual double PropagateToSurface(Particle&, double& Dt, double* Norm, TGeoVolume* &next, TPolyLine3D* u = 0)`
+* `virtual bool   Propagate(double dt, Particle&)`: moves the particles over a time `dt` (in seconds) 
+* `virtual double PropagateToSurface(Particle&, double& Dt, double* Norm, TGeoVolume* &next, TPolyLine3D* u = 0)`: moves the particle to the next interface of the geometry. At the end of the propagation, the particle must remains inside the initila volume, close to the surface. The return value shoud be the time, in seconds, spent during the step. The other arguments of the method are used as return values:
+    * `double& Dt`: time step (in seconds) needed for the neutron to move to the next volume.
+   * `double* Norm`: array of 3 elements, direction of the normal to surface, going outwards.
+   * `TGeoVolume* &next`: volume on the other side of the surface.
+   * `TPolyLine3D* u`: if provided, the computed step will be added to the neutron trajectory, that may be recoded afterwards.

-* `virtual void SetCurrentVolume(TGeoVolume* )`
+In addition, subparts of the geometry can be accesses though protected members:

-* `TObjArray * fNodes`
-* `int         kNodes`
-* `TGeoVolume* fCurrentVolume`
-* `TGeoShape * fCurrentShape`
-* `TGeoNode  * fCurrentNode`
+* `TObjArray * fNodes`: list of geometry nodes,
+* `int         kNodes`: number of nodes,
+* `TGeoVolume* fCurrentVolume`: current volume containing the neutron,
+* `TGeoShape * fCurrentShape`: shape associated the the current volume,
+* `TGeoNode  * fCurrentNode`: node associated to the current volume.

 ### Interaction
 The interaction plug-in inherits from the [`BaseInteraction`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BaseInteraction.h) class.
+The mandatory virtual methods are:

-* `virtual int SurfaceInteraction(Particle&, TGeoVolume* vin, TGeoVolume* vnext, double dt, double* norm, TGeoVolume*& newvol)`
-* `virtual int VolumeInteraction (Particle&, TGeoVolume* vin, double Dt)`
+* `virtual int VolumeInteraction (Particle&, TGeoVolume* vin, double Dt)`: decide if and how the particle interated in the volume during its propagatino to the surface. The arguments are the particle, the current volume and the time sptent to reach the surface. The returned integer is a code to forward to the output, if the neutron did not reach the surface, it must be 0, so the `SurfaceInteraction` method is not called.
+* `virtual int SurfaceInteraction(Particle&, TGeoVolume* vin, TGeoVolume* vnext, double dt, double* norm, TGeoVolume*& newvol)`: decide the interaction of the particle at the surface. Arguments are the particle, the current volume, the neighbouring volume, the time step needed to rach the volume, the normal to the surface. The last argument is used as a return value and should contain the new volume containing the neutron after interaction. In the neutron is transmitted to the neighbouring volume, it should be propagated within the new volume using the input time step using `BasePropagator::Propagate` method.
+The returned integer is a flag describing the neutron status to be forwarded to the output plug-in.

 A second random number generator can be accessed from within the class via the `static TRandom3 Gen` private member. It is initialized with the `int InteractionSeed` parameter from the main simulation script (see user manual).

 ### Output
-The outputplug-in inherits from the [`BaseOutputInterface`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BaseOutputInterface.h) class.
+The output plug-in inherits from the [`BaseOutputInterface`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BaseOutputInterface.h) class.
+The mandatory virtual methods are:

-* `virtual void BeginParticle(Particle&)`
-* `virtual void SaveStep  (Particle&, int vol, int sur, TGeoVolume* previous, TGeoVolume* interface)`
-* `virtual void EndParticle(Particle&, int vol, int sur, TGeoVolume* previous, TGeoVolume* interface)`
-* `virtual void Finalize()`
-
-* `TPolyLine3DWrap*Line3D`
-* `int kId`
-* `int kStep`  
+* `virtual void BeginParticle(Particle&)`:  called after generation and is typically used to save information on the initial state.
+* `virtual void SaveStep  (Particle&, int vol, int sur, TGeoVolume* vin, TGeoVolume* vnext)`: called after each propagation step. The two integer `vol` and `sur` are the return values of the `BaseInteraction::VolumeInteraction` and `BaseInteraction::SurfaceInteraction` methods. `vin` and `vnext` are pointers to the pre-step current volume and the neighbouring one.
+* `virtual void EndParticle(Particle&, int vol, int sur, TGeoVolume* previous, TGeoVolume* interface)`: called at the end of the steps, with the status of the last step.
+* `virtual void Finalize()`: called at the end of the simulation.

 -------------------------
 Previous: [User manual](Manual) -- Next: [Benchmarks](Benchmarks)

Advanced modified by Benoit CLEMENT

Benoit CLEMENT — Fri, 18 Apr 2014 19:22:27 -0000

--- v6
+++ v7
@@ -61,7 +61,7 @@
 Each kind of plug-in has a specific set of mandatory method to define.

 A STARucn run always defines four plug-ins: a generator, a propagator, an interaction and an output plug-in.
-The singleton class [`CoreProcess`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/CoreProcess.h) is desingned to hold pointers to all four plug-ins as well as the defined geometry.
+The singleton class [`CoreProcess`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/CoreProcess.h) is designed to hold pointers to all four plug-ins as well as the defined geometry.
 It can be retrieved at any point of the code through the static method `CoreProcess* CoreProcess::GetInstance()` and pointers can be publicly accessed:

 * Geometry: `Geometry* CoreProcess::fGeo`
@@ -80,19 +80,45 @@

 ### Generator
 The generator plug-in inherits from the [`BaseGenerator`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BaseGenerator.h) class.
-The only mandatory methods besides the `void Configure(std::string script)` method is, `virtual void Generate(Particle&)`. It fills the particle initial caracteristics : position, speed, and time. The [`Particle`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/Particle.h) class only contains these basic informations. If you need more data (E.G polarization), you'll first need to implement a new particle class that will inherit from `Particle`. 
+The only mandatory methods besides the `void Configure(std::string script)` method is, `virtual void Generate(Particle&)`. It fills the particle initial caracteristics : position, speed, and time. The particle class 

-In addition a second method can be overriden, `virtual bool Good()`, that tests the status of the generator. The simulation will stop at the generation step if it return `false`. By default, this method always return `true`.  
+In addition a third method can be overriden, `virtual bool Good()`, that test the status of the generator. The simulation will stop at the generation step if it return `false`. By default, this method always return `true`.  

+A random number generator can be accessed from within the class via the `static TRandom3  Gen` private member. It is initialized with the `int GenerationSeed` parameter from the main simulation script (see user manual).
+ 
 ### Propagator
 The propagator plug-in inherits from the [`BasePropagator`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BasePropagator.h) class.
+
+* `virtual bool   Propagate(double dt, Particle&)`
+* `virtual double PropagateToSurface(Particle&, double& Dt, double* Norm, TGeoVolume* &next, TPolyLine3D* u = 0)`
+
+* `virtual void SetCurrentVolume(TGeoVolume* )`
+
+* `TObjArray * fNodes`
+* `int         kNodes`
+* `TGeoVolume* fCurrentVolume`
+* `TGeoShape * fCurrentShape`
+* `TGeoNode  * fCurrentNode`

 ### Interaction
 The interaction plug-in inherits from the [`BaseInteraction`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BaseInteraction.h) class.

+* `virtual int SurfaceInteraction(Particle&, TGeoVolume* vin, TGeoVolume* vnext, double dt, double* norm, TGeoVolume*& newvol)`
+* `virtual int VolumeInteraction (Particle&, TGeoVolume* vin, double Dt)`
+  
+A second random number generator can be accessed from within the class via the `static TRandom3 Gen` private member. It is initialized with the `int InteractionSeed` parameter from the main simulation script (see user manual).
+
 ### Output
 The outputplug-in inherits from the [`BaseOutputInterface`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BaseOutputInterface.h) class.

+* `virtual void BeginParticle(Particle&)`
+* `virtual void SaveStep  (Particle&, int vol, int sur, TGeoVolume* previous, TGeoVolume* interface)`
+* `virtual void EndParticle(Particle&, int vol, int sur, TGeoVolume* previous, TGeoVolume* interface)`
+* `virtual void Finalize()`
+
+* `TPolyLine3DWrap*Line3D`
+* `int kId`
+* `int kStep`  

 -------------------------
 Previous: [User manual](Manual) -- Next: [Benchmarks](Benchmarks)

Advanced modified by Benoit CLEMENT

Benoit CLEMENT — Fri, 18 Apr 2014 19:08:07 -0000

--- v5
+++ v6
@@ -6,7 +6,7 @@
 [TOC]

 ## Script interface
-The interface between the code and the parameters file is done through the `ParameterReader` class.
+The interface between the code and the parameters file is done through the [`ParameterReader`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/ParameterReader.h) class.

 This class needs as input a file describing the user defined types, `void ParameterReader::AddTypeFile(const char*)`
 and one or several parameter files, using `void ParameterReader::AddParameterFile(const char*)` or `void ParameterReader::AddParameterFile(std::istream&)`.
@@ -56,35 +56,42 @@

 ## Plug-ins

-All STARucn plug-ins inherits from `ParameterReader` through the `Configurable` class.
+All STARucn plug-ins inherits from [`ParameterReader`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/ParameterReader.h) through the [`Configurable`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/Configurable.h) class.
 The user type script, '/script/parameters.typ' is common to all the plug-ins and does not need to to be specified. 
-Each king of plug-in has a specific set of mandatory method to define.
+Each kind of plug-in has a specific set of mandatory method to define.

-A STARucn run always defines four plug-ins: a `Generator`, a `Propagator`, an `Interaction` and an `Output` plug-in.
-The singleton class `CoreProcess` is desingned to hold pointers to all four plug-ins as well as the defined geometry.
-It can be retrieved at any point of the code through the static method `CoreProcess* CoreProcess::GetInstance()` and pointers can be publicly accessed~:
+A STARucn run always defines four plug-ins: a generator, a propagator, an interaction and an output plug-in.
+The singleton class [`CoreProcess`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/CoreProcess.h) is desingned to hold pointers to all four plug-ins as well as the defined geometry.
+It can be retrieved at any point of the code through the static method `CoreProcess* CoreProcess::GetInstance()` and pointers can be publicly accessed:
+
 * Geometry: `Geometry* CoreProcess::fGeo`
 * Generator: `BaseGenerator* CoreProcess::fGenerator`
 * Propagator: `BasePropagator* CoreProcess::fPropagator`
 * Interaction: `BaseInteraction* CoreProcess::fInteraction`
 * Output: `BaseOutputInterface* CoreProcess::fOutputInterface`
-All four plug-ins base class contains directly a pointer to the `CoreProcess` called `fCore`.
+
+All four plug-ins base classes contain directly a pointer to the `CoreProcess` called `fCore`.

 ### Common methods and members
-All plug-ins have an constructor that does not take any parameter and will be use to set default values to the class member.
-The plug-in configuration is done through the mandatory `void Configure(std::string script)` method. The script contains all the information necessary to configure the plug-in. the standard way to do that is to feed the script to the `ParameterReader` part of the plug-in (using `ParameterReader::AddParameterFile(std::string)`) but one can use any other mean to extract information the argument string. 
+All plug-ins must have a constructor that does not take any parameter and will be used to set default values to the class member.
+
+The plug-in configuration is done through the mandatory `void Configure(std::string script)` method. 
+The script contains all the information necessary to configure the plug-in. The standard way to do that is to feed the script to the `ParameterReader` part of the plug-in (using `ParameterReader::AddParameterFile(std::string)`) but one can use any other mean to extract information the argument string. 

 ### Generator
-The generator plug-in inherits from the `BaseGenerator` class.
+The generator plug-in inherits from the [`BaseGenerator`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BaseGenerator.h) class.
+The only mandatory methods besides the `void Configure(std::string script)` method is, `virtual void Generate(Particle&)`. It fills the particle initial caracteristics : position, speed, and time. The [`Particle`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/Particle.h) class only contains these basic informations. If you need more data (E.G polarization), you'll first need to implement a new particle class that will inherit from `Particle`. 
+
+In addition a second method can be overriden, `virtual bool Good()`, that tests the status of the generator. The simulation will stop at the generation step if it return `false`. By default, this method always return `true`.  

 ### Propagator
-The propagator plug-in inherits from the `BasePropagator` class.
+The propagator plug-in inherits from the [`BasePropagator`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BasePropagator.h) class.

 ### Interaction
-The interaction plug-in inherits from the `BaseInteraction` class.
+The interaction plug-in inherits from the [`BaseInteraction`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BaseInteraction.h) class.

 ### Output
-The outputplug-in inherits from the `BaseOutputInterface` class.
+The outputplug-in inherits from the [`BaseOutputInterface`](http://sourceforge.net/p/starucn/code-0/HEAD/tree/trunk/inc/core/BaseOutputInterface.h) class.

 -------------------------

Advanced modified by Benoit CLEMENT

Benoit CLEMENT — Fri, 18 Apr 2014 18:50:06 -0000

--- v4
+++ v5
@@ -72,7 +72,7 @@

 ### Common methods and members
 All plug-ins have an constructor that does not take any parameter and will be use to set default values to the class member.
-The plug-in configuration is done through the mandatory `void Configure(std::string script)` method. The script contains all the information necessary to configure the plug-in. the standard way to do that is to feed the script to the `ParameterReader` part of the plug-in (using `ParameterReader::AddParameterFile(std::string)`) but one can use any other mean to extract infomation the argument string. 
+The plug-in configuration is done through the mandatory `void Configure(std::string script)` method. The script contains all the information necessary to configure the plug-in. the standard way to do that is to feed the script to the `ParameterReader` part of the plug-in (using `ParameterReader::AddParameterFile(std::string)`) but one can use any other mean to extract information the argument string. 

 ### Generator
 The generator plug-in inherits from the `BaseGenerator` class.

Advanced modified by Benoit CLEMENT

Benoit CLEMENT — Fri, 18 Apr 2014 18:50:05 -0000

--- v3
+++ v4
@@ -1,15 +1,14 @@
 Advanced user manual

-This part of the manual describe how advanced users can implement their own plugins.
-If you have a plugin that you would like to see integrated in the standard STARucn release, please contact the author.
+This part of the manual describe how advanced users can implement their own plug-ins.
+If you have a plug-in that you would like to see integrated in the standard STARucn release, please contact the author.

 [TOC]

 ## Script interface
-The interface between the code and the parameters file is done through the `ParameterReader` and `Configurable` classes.
-### `ParameterReader`
-This class is the main interface to the script.
-It needs as input a file describing the user defined types, `void ParameterReader::AddTypeFile(const char*)`
+The interface between the code and the parameters file is done through the `ParameterReader` class.
+
+This class needs as input a file describing the user defined types, `void ParameterReader::AddTypeFile(const char*)`
 and one or several parameter files, using `void ParameterReader::AddParameterFile(const char*)` or `void ParameterReader::AddParameterFile(std::istream&)`.

 Any key of any parameter (`int`, `double`, `string`, `bool`) can be accessed through the method:
@@ -49,17 +48,44 @@
   }
 ~~~~~~ 

-
-
-
 Finally, two static methods provide additionary tools:  

 * `static void ParameterReader::ReadString(std::vector&, std::string, char = '|')`: decompose a string into a vector of substrings, eg. "a|b|c" -> {"a","b","c"}. The third parameter defines the substring separator within the initial string.
-* `static std::string ParameterReader::Substitute(std::string, char, char)` : substitute a char by another in string
+* `static std::string ParameterReader::Substitute(std::string, char, char)` : substitute a char by another in a string

-### `Configurable`

-## Plugins
+## Plug-ins
+
+All STARucn plug-ins inherits from `ParameterReader` through the `Configurable` class.
+The user type script, '/script/parameters.typ' is common to all the plug-ins and does not need to to be specified. 
+Each king of plug-in has a specific set of mandatory method to define.
+
+A STARucn run always defines four plug-ins: a `Generator`, a `Propagator`, an `Interaction` and an `Output` plug-in.
+The singleton class `CoreProcess` is desingned to hold pointers to all four plug-ins as well as the defined geometry.
+It can be retrieved at any point of the code through the static method `CoreProcess* CoreProcess::GetInstance()` and pointers can be publicly accessed~:
+* Geometry: `Geometry* CoreProcess::fGeo`
+* Generator: `BaseGenerator* CoreProcess::fGenerator`
+* Propagator: `BasePropagator* CoreProcess::fPropagator`
+* Interaction: `BaseInteraction* CoreProcess::fInteraction`
+* Output: `BaseOutputInterface* CoreProcess::fOutputInterface`
+All four plug-ins base class contains directly a pointer to the `CoreProcess` called `fCore`.
+
+### Common methods and members
+All plug-ins have an constructor that does not take any parameter and will be use to set default values to the class member.
+The plug-in configuration is done through the mandatory `void Configure(std::string script)` method. The script contains all the information necessary to configure the plug-in. the standard way to do that is to feed the script to the `ParameterReader` part of the plug-in (using `ParameterReader::AddParameterFile(std::string)`) but one can use any other mean to extract infomation the argument string. 
+
+### Generator
+The generator plug-in inherits from the `BaseGenerator` class.
+
+### Propagator
+The propagator plug-in inherits from the `BasePropagator` class.
+
+### Interaction
+The interaction plug-in inherits from the `BaseInteraction` class.
+
+### Output
+The outputplug-in inherits from the `BaseOutputInterface` class.
+

 -------------------------
 Previous: [User manual](Manual) -- Next: [Benchmarks](Benchmarks)

Advanced modified by Benoit CLEMENT

Benoit CLEMENT — Mon, 14 Apr 2014 06:20:25 -0000

--- v2
+++ v3
@@ -60,3 +60,6 @@
 ### `Configurable`

 ## Plugins
+
+-------------------------
+Previous: [User manual](Manual) -- Next: [Benchmarks](Benchmarks)

Advanced modified by Benoit CLEMENT

Benoit CLEMENT — Sun, 13 Apr 2014 19:51:10 -0000

--- v1
+++ v2
@@ -6,6 +6,57 @@
 [TOC]

 ## Script interface
+The interface between the code and the parameters file is done through the `ParameterReader` and `Configurable` classes.
+### `ParameterReader`
+This class is the main interface to the script.
+It needs as input a file describing the user defined types, `void ParameterReader::AddTypeFile(const char*)`
+and one or several parameter files, using `void ParameterReader::AddParameterFile(const char*)` or `void ParameterReader::AddParameterFile(std::istream&)`.
+
+Any key of any parameter (`int`, `double`, `string`, `bool`) can be accessed through the method:
+
+`template  T ParameterReader::GetParameter( std::string type, std::string name="", std::string key="")`
+
+where:
+
+* `type` is the parameter type
+* `name` is the parameter name. If not specified, the current parameter will be accessed (see iterators)
+* `key`  is the name of the key one want to access. For basic types (`int`, `double`, `string`, `bool`), this parameter isn't needed
+
+Alternatively, basic types can be accessed by shortcut methods:
+
+`int         ParameterReader::GetInt(std::string name="")`
+`std::string ParameterReader::GetString(std::string name="")` 
+`double      ParameterReader::GetDouble(std::string name="")` 
+`bool        ParameterReader::GetBool(std::string name="")` 
+
+For advanced options allow to loop over all variables of a given type, using iterators:
+
+
+* `void        ParameterReader::itrInit(std::string type)`: initialize the iterator on a type.
+* `void        ParameterReader::itrNext(std::string type)`: move to the next variable in this type. It is the variable which will be accessed if no name is pecified in `GetParameter`. 
+* `bool        ParameterReader::itrEnd(std::string type)`: true only if the end of the list has been reached
+* `std::string ParameterReader::itrName(std::string type)`: return the name of the current variable
+
+A typical loop one the type `mytype` will look like:
+
+~~~~~~
+ParameterReader pr
+...
+for(pr.itrInit("mytype"); !pr.itrEnd("mytype"); pr.itrNext("mytype"))
+  {
+  std::string name = pr.itrName("mytype");
+  ...
+  }
+~~~~~~ 
+
+
+
+
+Finally, two static methods provide additionary tools:  
+
+* `static void ParameterReader::ReadString(std::vector&, std::string, char = '|')`: decompose a string into a vector of substrings, eg. "a|b|c" -> {"a","b","c"}. The third parameter defines the substring separator within the initial string.
+* `static std::string ParameterReader::Substitute(std::string, char, char)` : substitute a char by another in string
+
+### `Configurable`

 ## Plugins
-

Advanced modified by Benoit CLEMENT

Benoit CLEMENT — Sat, 12 Apr 2014 10:20:04 -0000

Advanced user manual

This part of the manual describe how advanced users can implement their own plugins.
If you have a plugin that you would like to see integrated in the standard STARucn release, please contact the author.

Script interface
Plugins