source: trunk/yao/src/Translator.cpp @ 1

//! \file    Translator.cpp
//! \brief   Implementation of the Translator class, which handles both
//!          description analysis and code generation.
//! \version 2007/10/01 (yyyy/mm/dd) 
//! \author  Luigi Nardi <luiginardi(at)gmail.com> 
//
// This file is part of YAO, a framework for variational assimilation in
// numerical models.
// Copyright (c) 2001-onwards LOCEAN. All rights reserved.
//
// This program may be redistributed and/or modified under the terms of the GNU
// General Public License as published by the Free Software Foundation, either
// version 2 of the license, or (at your option) any later version.
//
// This program is provided AS IS and WITHOUT ANY WARRANTY, including any
// implied warranty of DESIGN, MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE.

#include "help/FilePath.hpp"
#include "Translator.hpp"
//#include "help/Enforcer.hpp"
#include "help/Helper.hpp"

#include <iomanip>
#include <numeric>

//PROVE--------
//#include <iostream>
#include <cstdlib>
#include <stdlib.h>

using namespace std;
using namespace yao;

//-------------------GLOBAL VARIABLES----------------------------------------
string projectName; 
int maxNbInput = 0;           // The old Wmaxnbi: the max number of input for a module.
int maxNbOutput = 0;          // The old Wmaxnbs: the max number of output for a module.
int maxNbJacobianInput = 0;   // The old Wmaxjacnbi: the max number of input for a module that needs automatic jacobian operations.
int maxNbJacobianOutput = 0;  // The old Wmaxjacnbs: the max number of output for a module that needs automatic jacobian operations.
char buffer[BUFSIZE + 1];     // Used in particular to perform the format.
int clonLevel = 0;            // Is the level of the clone: 2 all, 1 something.

// For the profiling of the parallelism:
int totalLoops = 0;           // Is the total number of loops generated analysing the order directive.
int parallelForwardLoops = 0; // Is the total number of parallelized loops for the forward generated analysing the order directive and the connections.
//int parallelBackwardLoops = 0;// Is the total number of parallelized loops for the backward generated analysing the order directive and the connections.
int parallelForwardModules = 0;      // Is the total number of parallelized modules found analysing the order directive and the connections.
//int parallelBackwardModules = 0;// Is the total number of parallelized modules found analysing the order directive and the connections.
int totalModulesInOrders = 0; // Is the total number of modules that are present in the order directive.
int totalAtomicOperations = 0;// Is the total number of atomic operations present in the order directive: this affect the performance.
//---------------------------------------------------------------------------

/**
 * The Translator constructor.
 * @param aTokenizer is the BaseLexer wrapper that handles the file opening and lexing.
 */
Translator::Translator(Tokenizer& aTokenizer): BaseParser(aTokenizer.theBaseLexer){
  this->setFilename(aTokenizer.theBaseLexer.getFilename());
  antlr::ASTFactory factory;
  this->initializeASTFactory(factory);
  this->setASTFactory(&factory);
}

/**
 * Generation of the code in function of the description file reed. 
 * This method call all the generate code methods relative to all the directives.
 */
void Translator::generateCode(){
  this->description(); // Description analysis.

  if(theDisplay.isHelp()) // Display the help menu if requested in the description file.
    this->theDisplay.displayHelp();

  if(theDisplay.isDefval()) // Display the Constant table if requested in the description file.
    this->theDisplay.display(theConstantTable);

  projectName = static_cast<FilePath>(this->getFilename()).getTitle();

  // Project declaration begins here.
  string filename = "Y1" + projectName + ".h";  // The declaration file, the file where all the declaration are located.
  ofstream declaration(filename.c_str(), ios::out | ios::binary);
  if(!declaration.is_open())
    throw ofstream::failure("couldn't create " + filename);

  // Project information (should also provide #include guard).
  declaration << endl << "//" << setfill('-') << setw(52) << "-" << setfill(' ') << endl;
  declaration << "// project: " << projectName << "     header generated by YAO version " << VERSION << endl;
  declaration << "//" << setfill('-') << setw(52) << "-" << setfill(' ') << endl << endl;

  // Define some parallelism stuffs
  if(theContext.isParallel()){
    declaration << "// DEFINE FOR PARALLELISM" << endl
      << "#define PARALLEL" << endl
      << "#ifdef _OPENMP" << endl
      << "  #include <omp.h>" << endl
      << "#else" << endl
      << "  #define omp_get_thread_num() 0" << endl
      << "  #define omp_get_num_threads() 1" << endl
      << "  #define omp_get_max_threads() 1" << endl
      << "#endif" << endl << endl;
  }else {
    declaration << "// DEFINE FOR PARALLELISM" << endl
      << "#define NOT_PARALLEL" << endl << endl;
  }

  declaration << "//€ € € € LES DECLARATIONS DE CLASS, DEFINE ET ALLOCATION DU PROJET" << endl;

  // Constants declaration.
  declaration.precision(numeric_limits<double>::digits10);

  // Exception for MQN, the constant Y3_M must be added.
  if(!theConstantTable.find(static_cast<string>("Y3_M")))
    theConstantTable.push_back(Constant(static_cast<string>("Y3_M"), static_cast<string>("8"))); 

  // Number of base 10 digits that can be represented without change.
  for(Table<Constant>::const_iterator it = theConstantTable.begin(); it != theConstantTable.end(); ++it)
    declaration << "#define \t" << it->getName() << " \t" << it->getText() << endl;

  // Code generation context (options) declaration.
  if(theContext.isExternal()){
    // Extern objects declaration file.
    filename = "Yaoext_" + projectName ;  // The extern objects file.
    ofstream externfile(filename.c_str(), ios::out | ios::binary);
    if(!externfile.is_open())
      throw ofstream::failure("couldn't create " + filename);
    this->generateCode(declaration, externfile,  theContext);
    externfile.close();
  }else this->generateCode(declaration, declaration,  theContext); 
  // Display the context if requested in the description file.
  if(theDisplay.isContext()){
    Table<Context> theContextTable; // Just for printing we create a table of context with only one element.
    theContextTable.push_back(theContext); // The table has just one element.
    this->theDisplay.display(theContextTable);
  }

  // Trajectories declaration.
  this->generateCode(declaration, theTrajectoryTable);
  // Display the trajectories if requested in the description file.
  if(theDisplay.isTrajectory())
    this->theDisplay.display(theTrajectoryTable);

  // So-called spaces (model operators) declaration.
  this->generateCode(declaration, theSpaceTable);
  // Display the spaces if requested in the description file.
  if(theDisplay.isSpace())
    this->theDisplay.display(theSpaceTable);

  // Operators declaration.
  this->generateCode(declaration, theOperatorTable);
  // Display the operators if requested in the description file.
  if(theDisplay.isOpera())
    this->theDisplay.display(theOperatorTable);

  // Project implementation begins here.
  filename = "Y2" + projectName + ".h"; // The function implementation file.
  ofstream implementation(filename.c_str(), ios::out | ios::binary);
  if(!implementation.is_open())
    throw ofstream::failure("couldn't create " + filename);

  // Project information (should also provide #include guard).
  implementation << endl << "//" << setfill('-') << setw(52) << "-" << setfill(' ') << endl;
  implementation << "// project: " << projectName << "     header generated by YAO version " << VERSION  << endl;
  implementation << "//" << setfill('-') << setw(52) << "-" << setfill(' ') << endl << endl;
  implementation << "// € € € € € € € € LES FONCTIONS PREDEFINIES" << endl;

  // cout << "Neuron......." << endl; // For see/debug.
  // Neural net: netward declaration.
  if(theNeuronTable.size())
    this->generateCode(declaration, implementation, theNeuronTable);
  // Display the neurons if requested in the description file.
  if(theDisplay.isNeuron())
    this->theDisplay.display(theNeuronTable);

  // cout << "Module......." << endl; // For see/debug.
  this->generateCode(declaration, implementation, theModulTable);
  // Display the Modules if requested in the description file.
  if(theDisplay.isModule())
    this->theDisplay.display(theModulTable);

  // cout << "connection......." << endl; // For see/debug.
  this->generateCode(theConnectionTable);
  
  // Display the connections if requested in the description file.
  if(theDisplay.isConnection())
    this->theDisplay.display(theConnectionTable);

  this->generateCode(implementation, theOrderTable);

  this->generateCode(implementation, theFunctionTable);

  // We have finished the generation of each directive. Here we have something more to generate lastly
  this->generateCode(declaration, implementation);

  // Close files declaration and implementation:
  declaration.close();
  implementation.close();
  // End Translator

 //Example sets the defined paths for the program to C:\
//Example then lists the paths
//    putenv("CIAO=parallel");
//    cout << getenv("CIAO");  

    
  
  //setenv("CIAO","parallel",1);



//  system( "CIAO=iiiiiiiiiiiiiiii" );
//  system( "export CIAO" );
//system( "echo $HOME" );
    
  


}

/**
 * Generation of the code relative to the directive option.
 * @param aDeclaration is the generated file we are writing on.
 * @param anExternal is the generated external file we are writing on if it is present in the options, nothing otherwise.
 * @param theContext is the object that contain all options and that define the context.
 */
void Translator::generateCode(ostream& aDeclaration, ostream& anExternal, Context& theContext){
  // This way we do not generate YO_TOOL if gradtest is defined because not useful (this is a difference with Charles code).
  if(theContext.isTool() && !theContext.isGradTest())       
    aDeclaration << "#define\t\tYO_TOOL\n";
  if(theContext.getNeuronSize()){
    aDeclaration << "#define\t\tYO_NETWARD\n";
    aDeclaration << "#define\t\tYNMAXCELL " << theContext.getNeuronSize() << endl;
  }
  if(theContext.isM1qn3())
    aDeclaration << "#define\t\tYO_M1QN3\n";
  if(theContext.isM2qn1())
    aDeclaration << "#define\t\tYO_M2QN1\n";
  if(theContext.isGradTest())
    aDeclaration << "#define\t\tYO_GRADTEST\n";
  if(theContext.isIncremental())
    aDeclaration << "#define\t\tYO_VARINCR\n";
  if(theContext.isDebugInput())
    aDeclaration << "#define\t\tYO_DBG_TING\n";
  if(theContext.isDebugBeta())
    aDeclaration << "#define\t\tYO_DBG_BETA\n"; 
  if(theContext.isDebugNan())
    aDeclaration << "#define\t\tYO_DBG_NANF\n";
  if(theContext.isDebugForward())
    aDeclaration << "#define\t\tYO_DBG_FWARD\n";
  if(theContext.isDebugBackward())
    aDeclaration << "#define\t\tYO_DBG_BWARD\n";
  if(theContext.isDebugLinward())
    aDeclaration << "#define\t\tYO_DBG_LWARD\n"; 
  if(theContext.isExternal()){
    // Header for the creation script of the external objects that we have to link.
    anExternal << "#!/bin/sh \nLDYEXTOBJ=\" ";
    vector<string> vect = theContext.getExternal();
    for(vector<string>::iterator it=vect.begin(); it!=vect.end(); it++)
      anExternal << (*it) << " ";
    anExternal << "\" "; 
  }
  if(theContext.isDouble()) {
    aDeclaration << "#define\t\tYDOUBLE \n";
    aDeclaration << "#define\t\tYTINY  1.e-15 \n";
  }else{
    aDeclaration << "#define\t\tYFLOAT \n";
    aDeclaration << "#define\t\tYTINY  1.e-8 \n";
  }
  aDeclaration << "#define\t\tYREAL " << theContext.getReal() << "\n";
}

/**
 * Generation of the code relative to the directive traj.
 * @param aDeclaration is the generated file we are writing on.
 * @param aTrajectoryTable is the table that contains all the objects trajectory.
 */
void Translator::generateCode(ostream& aDeclaration, Table<Trajectory>& aTrajectoryTable){
  for (Table<Trajectory>::const_iterator tra = theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); ++tra){
    int count = tra - aTrajectoryTable.begin();
    aDeclaration << endl << "#define\t\tYNBUPTIME_" << tra->getName() << "  \t"
      << tra->getBoot() << endl;
    aDeclaration << "#define\t\tYNBSTEPTIME_" << tra->getName() << "\t"
      << tra->getSize() << endl;
    aDeclaration << "#define\t\tYNBALLTIME_" << tra->getName() << "  \t"
      << tra->getBoot() + tra->getSize() << endl;
    aDeclaration << "#define\t\tYDt_"  << tra->getName() << " \tYTabTraj["
      << count << "].dtime" << endl;
    aDeclaration << "#define\t\tYid_" << tra->getName() << " \t" << count << endl;
  }
}

/**
 * Generation of the code relative to the directive opera.
 * @param aDeclaration is the generated file we are writing on.
 * @param anOperatorTable is the table that contains all the objects operator.
 */
void Translator::generateCode(ostream& aDeclaration, const Table<Operator>& anOperatorTable){
  for (Table<Operator>::const_iterator op = anOperatorTable.begin(); op != anOperatorTable.end(); ++op){
    aDeclaration << endl;
    for (int i=0; i < op->getDimension(); ++i)
      aDeclaration << "#define\t\tYA" << i + 1 << "_" << op->getName() << "\t\t" << op->getShape()[i] << endl;
    if (op->getDimension() == 3)
      aDeclaration << "#define\t\tYA2A3_" << op->getName() << "\t\t" << op->getShape()[1] * op->getShape()[2] << endl;
    aDeclaration << "#define\t\tYDIM_" << op->getName() << "\t\t" << op->getDimension() << endl;
    aDeclaration << "#define\t\tYNB_" << op->getName() << "\t\t" 
      << accumulate(op->getShape().begin(), op->getShape().end(), 1, multiplies<int>()) << endl;
    aDeclaration << "#define\t\tYid_" << op->getName() << " \t" << op - anOperatorTable.begin() << endl;
  }
}

/**
 * Generation of the code relative to the directive netward.
 * @param aDeclaration is the generated file we are writing on.
 * @param anImplementation is the generated file we are writing on.
 * @param aNeuronTable is the table that contains all the objects neuron.
 */
void Translator::generateCode(ostream& aDeclaration, ostream& anImplementation, const Table<Neuron>& aNeuronTable){
  ENFORCE(theContext.getNeuronSize())("no O_NETWARD option has been declared\n");
  aDeclaration << "\n\n// DECLARATION POUR DES RESEAUX DE NEURONES ... : \n";
  for(Table<Neuron>::const_iterator ne = aNeuronTable.begin(); ne != aNeuronTable.end(); ne++){
    aDeclaration << "#define  YNBI_" << ne->getName() << " " << ne->getInDegree() << "\n";
    aDeclaration << "#define  YNBS_" << ne->getName() << " " << ne->getOutDegree() <<  "\n";
    aDeclaration << "double  *YNTW_" << ne->getName() << ";\n";
    aDeclaration << "int      YNBW_" << ne->getName() << ";\n"; 
    aDeclaration << setw(6) << left << theContext.getReal() << "   YNTI_" << ne->getName() << "[" << ne->getInDegree() << "];\n";
    aDeclaration << setw(6) << left << theContext.getReal() << "   YNTS_" << ne->getName() << "[" << ne->getOutDegree() << "];\n";
    aDeclaration << setw(6) << left << theContext.getReal() << "   YNTG_" << ne->getName() << "[" << ne->getOutDegree() << "];\n";
    aDeclaration << setw(6) << left << theContext.getReal() << "   YNTD_" << ne->getName() << "[" << ne->getInDegree() << "];\n";
    aDeclaration << "#define  YNID_" << ne->getName() << " " << ne - aNeuronTable.begin() << "\n\n";

    MACRO0_NETLOD(ne->getName().c_str(), ne - aNeuronTable.begin()); // Wheight load of the Neuron Net.
    anImplementation << buffer;
    if(ne->getInDegree() > maxNbInput) maxNbInput = ne->getInDegree();      // The input output number of the net 
    if(ne->getOutDegree() > maxNbOutput) maxNbOutput = ne->getOutDegree();  // are used in order to determine the max value.
  }
}

/**
 * Generation of the code relative to the directive modul.
 * @param aDeclaration is the generated file we are writing on.
 * @param anImplementation is the generated file we are writing on.
 * @param aModulTable is the table that contains all the objects modul.
 */
void Translator::generateCode(ostream& aDeclaration, ostream& anImplementation, Table<Modul>& aModuleTable){
  long sizeM1qn3=0;                         // Dimension of the problem = sum the number of states of target.     
  int sizeCout=0;                           // Size off all modules cout: that's for the test functions.
  int modId=0;                              // The module ID.
  int w1, w2, w3;                           // Some counters useful in the generation process.
  string traj;                              // The trajectory currently analyzed.
  string filename;                          // It is the automatic differentiation file (in the case automatic differentiation is defined).
  ostringstream  bufwrk;                    // A stream buffer to perform some work with strings.
  ofstream automaticDifferentiation;        // It is the automatic differentiation stream linked to the automatic differentiation file.
  ostringstream streamInputWardFunctions;   // It's useful in order to generate the string inputWardFunctions.
  string inputWardFunctions;                // Parameters in input for functions *ward (Yting[i] sequence in Y2_project_file).
  char YREAL[7];                            // Used in macros, we leave this declaration because at the moment we don't want change the Charles macros.
  strcpy(YREAL, theContext.getReal().c_str());
  char modul[LG_MAX_STRING + 1];            // Name of the actual module, used in macro's generation.
  char spaceOrOperator[LG_MAX_STRING + 1];  // Name of the actual Space or Operator, used in macro's generation.
  long Y3SizeRz2, Y3SizeRz3;                // Vectors dimension for m1qn2 and/or m1qn3 (rz is a characteristic of the minimizer).
  char c1;                                  // A letter that say if the covt module is himself or not.

  if(theModulTable.size())
    aDeclaration << "\n/*----------------- GENERATION OF MODULES... -------------*/\n";
  for(Table<Modul>::iterator it=aModuleTable.begin(); it != aModuleTable.end(); it++, modId++){

    // FIRST PART: SOME CHECK & INIT of variables performed for each module already stocked from the grammar.
    // ------------------------------------------------------------------------------------------------------
    strcpy(modul, it->getName().c_str());
    strcpy(spaceOrOperator, it->getSpaceOrOperator().c_str());
    // Call of the function that control the cross options inside a module. This module member function also perform 
    // the adding of some values to the member's object. This values are directly accessed later in the generation of the code.
    it->checkCrossOption(theSpaceTable, theOperatorTable, theContext, theModulTable, theNeuronTable);
    // Set of global variables.
    // Determination of the max for input output of modules.
    if(it->isInput() && it->getInput() > maxNbInput)
      maxNbInput = it->getInput();
    if(it->isOutput() && it->getOutput() > maxNbOutput)
      maxNbOutput = it->getOutput();
    // Determination of the max for the jacobian (Yjac).
    if(!it->isHidjac() && !it->isNetward() && !it->isAutonet()){         
      if(it->getInput() > maxNbJacobianInput) maxNbJacobianInput = it->getInput();
      if(it->getOutput() > maxNbJacobianOutput) maxNbJacobianOutput = it->getOutput();
    }

    if(it->isClonol())
      clonLevel = 2; // With clonol we clone everything of the module inherited.

    if(it->isTarget()){ // Calculates the dimension of the problem for M1qn3.
      if(it->getNbStepTarget())
        sizeM1qn3 += it->getNbStepTarget() * it->getOutput() * it->getGridPoints();
      else sizeM1qn3 += it->getOutput() * it->getGridPoints();
    }

    if(it->isCout()) // Calculates the dimension of cout for the test functions.
      sizeCout += it->getOutput() * it->getGridPoints();

    // SECOND PART: --------------------------------Macro call and write into the files.
    // ---------------------------------------------------------------------------------
    aDeclaration << "\n//~~~~~~~~~~~~~~~~~~~~~~~~~ module " << modul << "~~~~~~~~~~~~~~~~~~~~~~~~~\n";
    aDeclaration << "#define Yid_" << modul << " " << modId << "\n";

    if(it->isOnAdf()){
      if(filename.empty()){ // The first time that we find a module automatic differentiation we create the file.
        filename = "Y3" + projectName + ".l";  // The automatic differentiation file.
        automaticDifferentiation.open(filename.c_str(), ios::out | ios::binary);
        if (!automaticDifferentiation.is_open())
          throw ofstream::failure("couldn't create " + filename);
        // Header for the differentiation file: performed one time.
        automaticDifferentiation << "#" << theContext.getAutoDiffWriteMode() << "liste des modules a deriver automatiquement\n";
      }
      // We add a module on the list of modules to be derivated automatically.
      automaticDifferentiation << modul << " " << it->getInput() << " " << it->getOutput();
    }

    if(it->isTarget()){        
      aDeclaration << "#define YNBPTARGET_" << modul << " " <<  it->getNbStepTarget() << "\n";
      aDeclaration << "#define YDEBTARGET_" << modul << " " <<  it->getBeginTarget() << "\n";
      aDeclaration << "#define YENDTARGET_" << modul << " " <<  it->getEndTarget() << "\n";
    }
    // Line 2733 Yao8.c
    if(theContext.isGradTestOrIncremental()){
      if(it->getNbAxes()==1){
        MACRO1_VALST(modul, 'D', YDELTA);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO1_VALSIT(modul, 'D', YDELTA, w1);  aDeclaration << buffer;
        }// We could perform just one "for" but the information will be mixed.
        for (w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO1_HERESIT(modul, 'D', YDELTA, w1);  aDeclaration << buffer;
        }
      }else if(it->getNbAxes()==2){
        MACRO2_VALST(modul, 'D', YDELTA);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO2_VALSIT(modul, 'D', YDELTA, w1);  aDeclaration << buffer;
        }// We could perform just one "for" but the information will be mixed.
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO2_HERESIT(modul, 'D', YDELTA, w1);  aDeclaration << buffer;
        }
      }else if(it->getNbAxes()==3){
        MACRO3_VALST(modul, 'D', YDELTA);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO3_VALSIT(modul, 'D', YDELTA, w1);  aDeclaration << buffer;
        }// We could perform just one "for" but the information will be mixed.
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO3_HERESIT(modul, 'D', YDELTA, w1);  aDeclaration << buffer;
        }
      }
    }

    if(!it->isCloned()) // Not cloned.
      aDeclaration << "\nclass Yao" << it->getName() << ";\n";
    if(!it->isNoward())  // Not noward  i.e. case of a normal module with a source.h. 
      aDeclaration << "class " << it->getName() << ";\n";
    if(it->isInter()){        
      MACRO0_NBMOD(modul, it->getGridPoints());  aDeclaration << buffer;}
    // We always have the number of output for a module. 
    MACRO0_NBSMOD(modul, it->getOutput()); 
    aDeclaration << buffer;
    if(it->getInput()){ // If there are inputs this is the input's number of a module. 
      MACRO0_NBIMOD(modul, it->getInput());     aDeclaration << buffer;}
    if(theContext.isGradTest()){  // We constitute the input parameters handling of *ward functions. 
      streamInputWardFunctions.str("");
      inputWardFunctions = "";
      if(!it->isAutonet() && !it->isArray()){ // Not for autonet and in_array. 
        for(w1=0; w1<it->getInput(); ++w1){   
          streamInputWardFunctions << " Yting[" << w1 << "],";
          ENFORCE(streamInputWardFunctions.str().size() < BUFSIZE)("-->buffer not big enough for parameters sending; see your Yao administrator\n");
        }
        inputWardFunctions = streamInputWardFunctions.str();
        if(inputWardFunctions.size())
          inputWardFunctions.replace(inputWardFunctions.size()-1, 1, " ");
      }
    }
    // Line 2805 Yao8.c dim=1
    // In function of the dimension ..........................................................*/
    if(it->getNbAxes()==1){
      MACRO1_IRMOD(modul, it->getCharAxe1());       aDeclaration << buffer;
      MACRO1_NOWMOD(modul, it->getCharAxe1());      aDeclaration << buffer;
      if(it->isTarget()){   // Case: target.
        if(it->isTempo()){  // Case: target, tempo. 
          MACRO1_ADJUST(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isIncremental()){  
            MACRO1_ADJUDT(modul, spaceOrOperator); anImplementation << buffer;
            MACRO1_ADJUKT(modul, spaceOrOperator); anImplementation << buffer; 
          }
          MACRO1_GCTOTBT(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isM1qn3()){      
            MACRO1_VSTAT(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO1_GSTAT(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO1_VGRADT(modul, spaceOrOperator);  anImplementation << buffer;
            if(theContext.isM2qn1()){  
              MACRO1_VXINFT(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO1_VXSUPT(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO1_VDXMIT(modul, spaceOrOperator);  anImplementation << buffer;
            }
            if(theContext.isIncremental()){  
              MACRO1_GDELT(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO1_VDELT(modul, spaceOrOperator);  anImplementation << buffer;
            }
          }
        }else{ // Case: target, not tempo. 
          MACRO1_ADJUS(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isIncremental()){  
            MACRO1_ADJUD(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO1_ADJUK(modul, spaceOrOperator);  anImplementation << buffer;
          }
          MACRO1_GCTOTB(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isM1qn3()){      
            MACRO1_VSTA(modul, spaceOrOperator);  anImplementation << buffer; 
            MACRO1_GSTA(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO1_VGRAD(modul, spaceOrOperator);  anImplementation << buffer;
            if(theContext.isM2qn1()){  
              MACRO1_VXINF(modul, spaceOrOperator);  anImplementation << buffer; 
              MACRO1_VXSUP(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO1_VDXMI(modul, spaceOrOperator);  anImplementation << buffer;
            }
            if(theContext.isIncremental()){  
              MACRO1_GDEL(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO1_VDEL(modul, spaceOrOperator);  anImplementation << buffer;
            }
          }
        } // End if tempo else.
      }// End if target.

      // For state and grad, we have to distinguish between temporized and not temporized. 
      if(it->isTempo()){ // Case of temporized modules (ex: Nit).
        MACRO1_VALST(modul, 'S', YSTATE);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO1_VALSIT(modul, 'S', YSTATE, w1);  aDeclaration << buffer; 
          MACRO1_HERESIT(modul, 'S', YSTATE, w1);  aDeclaration << buffer; 
        }
        MACRO1_VALST(modul, 'G', YGRAD);                    aDeclaration << buffer; 
        for (w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO1_VALSIT(modul, 'G', YGRAD, w1);   aDeclaration << buffer;
          MACRO1_HERESIT(modul, 'G', YGRAD, w1);  aDeclaration << buffer;
        }
        MACRO1_TBTOGT(modul, spaceOrOperator);  anImplementation << buffer;
        // If it's O_GRADTEST or O_VARINCR: we need of the zone delta.
        if(theContext.isGradTest() || (theContext.isIncremental() && it->isTarget()) ){
          MACRO1_GEQPDT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_DEQPST(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_DEQPGT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_SEQPDT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_SEQPODT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_SEQAPTDT(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isIncremental()){ 
          MACRO1_GEQVT(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isTool()) {
          MACRO1_GEQPST(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_GEQPOST(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_STOTBT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_GTOTBT(modul, spaceOrOperator);  anImplementation << buffer;
        }
        bufwrk.str("");
        bufwrk << "YNBALLTIME_" << it->getTrajectory();
        MACRO1_RGRADT(modul, spaceOrOperator, bufwrk.str().c_str());  anImplementation << buffer;
        MACRO1_SETAT(modul, spaceOrOperator, bufwrk.str().c_str());  anImplementation << buffer;
        MACRO1_YIOUT(modul);  anImplementation << buffer;
        if(theContext.isGradTest()){
          if(!it->isNetward() && !it->isAutonet() && !it->isNoward() && !it->isHidjac()){
            // This is not for NN, for noward and for hidjac modules.
            MACRO00_GTEST(modul);  anImplementation << buffer;
            MACRO01_GTESTT(inputWardFunctions.c_str()); anImplementation << buffer;
          }
        }
        if(it->isCout() || it->isTarget()){      
          MACRO0_OUTOB(modul);  anImplementation << buffer;
          MACRO1_OUTOBT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO9_OUTOB();  anImplementation << buffer;
        }
      }else{ // Case of not temporized modules (ex: Bio).
        MACRO1_VALSG(modul, 'S', YSTATE);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO1_VALSGI(modul, 'S', YSTATE, w1);  aDeclaration << buffer;     
          MACRO1_HERESGI(modul, 'S', YSTATE, w1); aDeclaration << buffer;
        }
        MACRO1_VALSG(modul, 'G', YGRAD);  aDeclaration << buffer;
        for (w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO1_VALSGI(modul, 'G', YGRAD, w1); aDeclaration << buffer;
          MACRO1_HERESGI(modul, 'G', YGRAD, w1); aDeclaration << buffer;
        }
        MACRO1_TBTOG(modul, spaceOrOperator);  anImplementation << buffer;
        // If it's O_GRADTEST or O_VARINCR: we need of the zone delta.
        if (theContext.isGradTest() || (theContext.isIncremental() && it->isTarget())){
          MACRO1_GEQPD(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_DEQPS(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_DEQPG(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_SEQPD(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_SEQPOD(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_SEQAPTD(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isIncremental()){ 
          MACRO1_GEQV(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isTool()){
          MACRO1_GEQPS(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_GEQPOS(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_STOTB(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO1_GTOTB(modul, spaceOrOperator);  anImplementation << buffer;
        }
        MACRO1_RGRAD(modul, spaceOrOperator);  anImplementation << buffer;
        MACRO1_SETA(modul, spaceOrOperator);  anImplementation << buffer;
        MACRO1_YIOTU(modul);  anImplementation << buffer;
        if(theContext.isGradTest()){
          if(!it->isNetward() && !it->isAutonet() && !it->isNoward() && !it->isHidjac()){
            // This is not for NN, for noward and for hidjac modules.
            MACRO00_GTEST(modul);  anImplementation << buffer;
            MACRO01_GTEST(inputWardFunctions.c_str()); anImplementation << buffer;
          }
        }
        if(it->isCout() || it->isTarget()){  
          MACRO0_OUTOB(modul);  anImplementation << buffer;
          MACRO1_OUTOB(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO9_OUTOB();  anImplementation << buffer;
        }
      } // End if tempo else 

      // Tempo or not tempo: 
      if(it->isTarget()){      
        MACRO1_VALSG(modul, 'E', YEPSI);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){         
          MACRO1_VALSGI(modul, 'E', YEPSI, w1);   aDeclaration << buffer;
        }
        MACRO1_SEPS(modul, spaceOrOperator);    anImplementation << buffer;
      }
      if(it->isNoward()){  
        sprintf (buffer, "Yao%s", modul);
        MACRO1_PTRMOD(buffer, modul, it->getStrYA1SpaceOperator().c_str());     aDeclaration << buffer;
        MACRO1_CREY(modul, spaceOrOperator);      anImplementation << buffer;
      }
      else{      
        MACRO1_PTRMOD(modul, modul, it->getStrYA1SpaceOperator().c_str());      aDeclaration << buffer;
        MACRO1_CREU(modul, spaceOrOperator);      anImplementation << buffer;
      }
      if(it->isCout() || it->isTarget()){      
        MACRO1_VALSG(modul, 'W', YWISH);    aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){               
          MACRO1_VALSGI(modul, 'W', YWISH, w1);     aDeclaration << buffer;
          MACRO1_HERESGI(modul, 'W', YWISH, w1);    aDeclaration << buffer;
        }
        MACRO1_SWISH(modul, spaceOrOperator);     anImplementation << buffer;
      }
      // Line 3022 Yao8.c ------> Begin dim=2
    }else if(it->getNbAxes()==2){
      MACRO2_IRMOD(modul, it->getCharAxe1(), it->getCharAxe2());       aDeclaration << buffer;
      MACRO2_NOWMOD(modul, it->getCharAxe1(), it->getCharAxe2());      aDeclaration << buffer;
      if(it->isTarget()){   // Case: target.
        if(it->isTempo()){  // Case: target, tempo. 
          MACRO2_ADJUST(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isIncremental()){  
            MACRO2_ADJUDT(modul, spaceOrOperator); anImplementation << buffer;
            MACRO2_ADJUKT(modul, spaceOrOperator); anImplementation << buffer; 
          }
          MACRO2_GCTOTBT(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isM1qn3()){      
            MACRO2_VSTAT(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO2_GSTAT(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO2_VGRADT(modul, spaceOrOperator);  anImplementation << buffer;
            if(theContext.isM2qn1()){  
              MACRO2_VXINFT(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO2_VXSUPT(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO2_VDXMIT(modul, spaceOrOperator);  anImplementation << buffer;
            }
            if(theContext.isIncremental()){  
              MACRO2_GDELT(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO2_VDELT(modul, spaceOrOperator);  anImplementation << buffer;
            }
          }
        }else{ // Case: target, not tempo. 
          MACRO2_ADJUS(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isIncremental()){  
            MACRO2_ADJUD(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO2_ADJUK(modul, spaceOrOperator);  anImplementation << buffer;
          }
          MACRO2_GCTOTB(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isM1qn3()){      
            MACRO2_VSTA(modul, spaceOrOperator);  anImplementation << buffer; 
            MACRO2_GSTA(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO2_VGRAD(modul, spaceOrOperator);  anImplementation << buffer;
            if(theContext.isM2qn1()){  
              MACRO2_VXINF(modul, spaceOrOperator);  anImplementation << buffer; 
              MACRO2_VXSUP(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO2_VDXMI(modul, spaceOrOperator);  anImplementation << buffer;
            }
            if(theContext.isIncremental()){  
              MACRO2_GDEL(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO2_VDEL(modul, spaceOrOperator);  anImplementation << buffer;
            }
          }
        } // End if tempo else.
      }   // End if target.

      //For state and grad, we have to distinguish between temporized and not temporized. 
      if(it->isTempo()){ // Case of temporized modules (ex: Nit).
        MACRO2_VALST(modul, 'S', YSTATE);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO2_VALSIT(modul, 'S', YSTATE, w1);  aDeclaration << buffer; 
          MACRO2_HERESIT(modul, 'S', YSTATE, w1);  aDeclaration << buffer; 
        }
        MACRO2_VALST(modul, 'G', YGRAD);                    aDeclaration << buffer; 
        for (w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO2_VALSIT(modul, 'G', YGRAD, w1);   aDeclaration << buffer;
          MACRO2_HERESIT(modul, 'G', YGRAD, w1);  aDeclaration << buffer;
        }
        MACRO2_TBTOGT(modul, spaceOrOperator);  anImplementation << buffer;
        // If it's O_GRADTEST or O_VARINCR: we need of the zone delta.
        if(theContext.isGradTest() || (theContext.isIncremental() && it->isTarget()) ){
          MACRO2_GEQPDT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_DEQPST(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_DEQPGT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_SEQPDT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_SEQPODT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_SEQAPTDT(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isIncremental()){ 
          MACRO2_GEQVT(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isTool()) {
          MACRO2_GEQPST(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_GEQPOST(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_STOTBT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_GTOTBT(modul, spaceOrOperator);  anImplementation << buffer;
        }
        bufwrk.str("");
        bufwrk << "YNBALLTIME_" << it->getTrajectory();
        MACRO2_RGRADT(modul, spaceOrOperator, bufwrk.str().c_str());  anImplementation << buffer;
        MACRO2_SETAT(modul, spaceOrOperator, bufwrk.str().c_str());  anImplementation << buffer;
        MACRO2_YIOUT(modul);  anImplementation << buffer;
        if(theContext.isGradTest()){
          if(!it->isNetward() && !it->isAutonet() && !it->isNoward() && !it->isHidjac()){
            // This is not for NN, for noward and for hidjac modules.
            MACRO00_GTEST(modul);  anImplementation << buffer;
            MACRO01_GTESTT(inputWardFunctions.c_str()); anImplementation << buffer; // Control!!
          }
        }
        if(it->isCout() || it->isTarget()){      
          MACRO0_OUTOB(modul);  anImplementation << buffer;
          MACRO2_OUTOBT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO9_OUTOB();  anImplementation << buffer;
        }
      }else{ // Case of not temporized modules (ex: Bio).
        MACRO2_VALSG(modul, 'S', YSTATE);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO2_VALSGI(modul, 'S', YSTATE, w1);  aDeclaration << buffer;     
          MACRO2_HERESGI(modul, 'S', YSTATE, w1); aDeclaration << buffer;
        }
        MACRO2_VALSG(modul, 'G', YGRAD);  aDeclaration << buffer;
        for (w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO2_VALSGI(modul, 'G', YGRAD, w1); aDeclaration << buffer;
          MACRO2_HERESGI(modul, 'G', YGRAD, w1); aDeclaration << buffer;
        }
        MACRO2_TBTOG(modul, spaceOrOperator);  anImplementation << buffer;
        // If it's O_GRADTEST or O_VARINCR: we need of the zone delta.
        if(theContext.isGradTest() || (theContext.isIncremental() && it->isTarget())){
          MACRO2_GEQPD(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_DEQPS(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_DEQPG(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_SEQPD(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_SEQPOD(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_SEQAPTD(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isIncremental()){ 
          MACRO2_GEQV(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isTool()){
          MACRO2_GEQPS(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_GEQPOS(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_STOTB(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO2_GTOTB(modul, spaceOrOperator);  anImplementation << buffer;
        }
        MACRO2_RGRAD(modul, spaceOrOperator);  anImplementation << buffer;
        MACRO2_SETA(modul, spaceOrOperator);  anImplementation << buffer;
        MACRO2_YIOTU(modul);  anImplementation << buffer;
        if(theContext.isGradTest()){
          if(!it->isNetward() && !it->isAutonet() && !it->isNoward() && !it->isHidjac()){
            // This is not for NN, for noward and for hidjac modules.
            MACRO00_GTEST(modul);  anImplementation << buffer;
            MACRO01_GTEST(inputWardFunctions.c_str()); anImplementation << buffer; // Control!!
          }
        }
        if(it->isCout() || it->isTarget()){  
          MACRO0_OUTOB(modul);  anImplementation << buffer;
          MACRO2_OUTOB(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO9_OUTOB();  anImplementation << buffer;
        }
      } // End if tempo else.

      // Tempo or not tempo: 
      if(it->isTarget()){      
        MACRO2_VALSG(modul, 'E', YEPSI);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){         
          MACRO2_VALSGI(modul, 'E', YEPSI, w1);   aDeclaration << buffer;
        }
        MACRO2_SEPS(modul, spaceOrOperator);    anImplementation << buffer;
      }
      if(it->isNoward()){  
        sprintf (buffer, "Yao%s", modul);
        MACRO2_PTRMOD(buffer, modul, it->getStrYA1SpaceOperator().c_str(), it->getStrYA2SpaceOperator().c_str());       aDeclaration << buffer;
        MACRO2_CREY(modul, spaceOrOperator);      anImplementation << buffer;
      }
      else{      
        MACRO2_PTRMOD(modul, modul, it->getStrYA1SpaceOperator().c_str(), it->getStrYA2SpaceOperator().c_str());        aDeclaration << buffer;
        MACRO2_CREU(modul, spaceOrOperator);      anImplementation << buffer;
      }
      if(it->isCout() || it->isTarget()){      
        MACRO2_VALSG(modul, 'W', YWISH);    aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){               
          MACRO2_VALSGI(modul, 'W', YWISH, w1);     aDeclaration << buffer;
          MACRO2_HERESGI(modul, 'W', YWISH, w1);    aDeclaration << buffer;
        }
        MACRO2_SWISH(modul, spaceOrOperator);     anImplementation << buffer;
      }
      // Line 3239 Yao8.c ------> Begin dim=3.
    }else if(it->getNbAxes()==3){
      MACRO3_IRMOD(modul);       aDeclaration << buffer;
      MACRO3_NOWMOD(modul);      aDeclaration << buffer;
      if(it->isTarget()){   // Case: target.
        if(it->isTempo()){  // Case: target, tempo. 
          MACRO3_ADJUST(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isIncremental()){  
            MACRO3_ADJUDT(modul, spaceOrOperator); anImplementation << buffer;
            MACRO3_ADJUKT(modul, spaceOrOperator); anImplementation << buffer; 
          }
          MACRO3_GCTOTBT(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isM1qn3()){      
            MACRO3_VSTAT(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO3_GSTAT(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO3_VGRADT(modul, spaceOrOperator);  anImplementation << buffer;
            if(theContext.isM2qn1()){  
              MACRO3_VXINFT(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO3_VXSUPT(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO3_VDXMIT(modul, spaceOrOperator);  anImplementation << buffer;
            }
            if(theContext.isIncremental()){  
              MACRO3_GDELT(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO3_VDELT(modul, spaceOrOperator);  anImplementation << buffer;
            }
          }
        }else{ // Case: target, not tempo. 
          MACRO3_ADJUS(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isIncremental()){  
            MACRO3_ADJUD(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO3_ADJUK(modul, spaceOrOperator);  anImplementation << buffer;
          }
          MACRO3_GCTOTB(modul, spaceOrOperator);  anImplementation << buffer;
          if(theContext.isM1qn3()){      
            MACRO3_VSTA(modul, spaceOrOperator);  anImplementation << buffer; 
            MACRO3_GSTA(modul, spaceOrOperator);  anImplementation << buffer;
            MACRO3_VGRAD(modul, spaceOrOperator);  anImplementation << buffer;
            if(theContext.isM2qn1()){  
              MACRO3_VXINF(modul, spaceOrOperator);  anImplementation << buffer; 
              MACRO3_VXSUP(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO3_VDXMI(modul, spaceOrOperator);  anImplementation << buffer;
            }
            if(theContext.isIncremental()){  
              MACRO3_GDEL(modul, spaceOrOperator);  anImplementation << buffer;
              MACRO3_VDEL(modul, spaceOrOperator);  anImplementation << buffer;
            }
          }
        } // End if tempo else.
      }   // End if target.

      // For state and grad, we have to distinguish between temporized and not temporized. 
      if(it->isTempo()){ // Case of temporized modules (ex: Nit).
        MACRO3_VALST(modul, 'S', YSTATE);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO3_VALSIT(modul, 'S', YSTATE, w1);  aDeclaration << buffer; 
          MACRO3_HERESIT(modul, 'S', YSTATE, w1);  aDeclaration << buffer; 
        }
        MACRO3_VALST(modul, 'G', YGRAD);                    aDeclaration << buffer; 
        for (w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO3_VALSIT(modul, 'G', YGRAD, w1);   aDeclaration << buffer;
          MACRO3_HERESIT(modul, 'G', YGRAD, w1);  aDeclaration << buffer;
        }
        MACRO3_TBTOGT(modul, spaceOrOperator);  anImplementation << buffer;
        // If it's O_GRADTEST or O_VARINCR: we need of the zone delta.
        if(theContext.isGradTest() || (theContext.isIncremental() && it->isTarget()) ){
          MACRO3_GEQPDT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_DEQPST(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_DEQPGT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_SEQPDT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_SEQPODT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_SEQAPTDT(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isIncremental()){ 
          MACRO3_GEQVT(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isTool()) {
          MACRO3_GEQPST(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_GEQPOST(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_STOTBT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_GTOTBT(modul, spaceOrOperator);  anImplementation << buffer;
        }
        bufwrk.str("");
        bufwrk << "YNBALLTIME_" << it->getTrajectory();
        MACRO3_RGRADT(modul, spaceOrOperator, bufwrk.str().c_str());  anImplementation << buffer;
        MACRO3_SETAT(modul, spaceOrOperator, bufwrk.str().c_str());  anImplementation << buffer;
        MACRO3_YIOUT(modul);  anImplementation << buffer;
        if(theContext.isGradTest()){
          if(!it->isNetward() && !it->isAutonet() && !it->isNoward() && !it->isHidjac()){
            // This is not for NN, for noward and for hidjac modules.
            MACRO00_GTEST(modul);  anImplementation << buffer;
            MACRO01_GTESTT(inputWardFunctions.c_str()); anImplementation << buffer; // Control!!
          }
        }
        if(it->isCout() || it->isTarget()){      
          MACRO0_OUTOB(modul);  anImplementation << buffer;
          MACRO3_OUTOBT(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO9_OUTOB();  anImplementation << buffer;
        }
      }else{ // Case of not temporized modules (ex: Bio).
        MACRO3_VALSG(modul, 'S', YSTATE);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO3_VALSGI(modul, 'S', YSTATE, w1);  aDeclaration << buffer;     
          MACRO3_HERESGI(modul, 'S', YSTATE, w1); aDeclaration << buffer;
        }
        MACRO3_VALSG(modul, 'G', YGRAD);  aDeclaration << buffer;
        for (w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){
          MACRO3_VALSGI(modul, 'G', YGRAD, w1); aDeclaration << buffer;
          MACRO3_HERESGI(modul, 'G', YGRAD, w1); aDeclaration << buffer;
        }
        MACRO3_TBTOG(modul, spaceOrOperator);  anImplementation << buffer;
        // If it's O_GRADTEST or O_VARINCR: we need of the zone delta.
        if(theContext.isGradTest() || (theContext.isIncremental() && it->isTarget())){
          MACRO3_GEQPD(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_DEQPS(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_DEQPG(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_SEQPD(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_SEQPOD(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_SEQAPTD(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isIncremental()){ 
          MACRO3_GEQV(modul, spaceOrOperator);  anImplementation << buffer;
        }
        if(theContext.isTool()){
          MACRO3_GEQPS(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_GEQPOS(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_STOTB(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO3_GTOTB(modul, spaceOrOperator);  anImplementation << buffer;
        }
        MACRO3_RGRAD(modul, spaceOrOperator);  anImplementation << buffer;
        MACRO3_SETA(modul, spaceOrOperator);  anImplementation << buffer;
        MACRO3_YIOTU(modul);  anImplementation << buffer;
        if(theContext.isGradTest()){
          if(!it->isNetward() && !it->isAutonet() && !it->isNoward() && !it->isHidjac()){
            // This is not for NN, for noward and for hidjac modules.
            MACRO00_GTEST(modul);  anImplementation << buffer;
            MACRO01_GTEST(inputWardFunctions.c_str()); anImplementation << buffer; // Control!!
          }
        }
        if(it->isCout() || it->isTarget()){  
          MACRO0_OUTOB(modul);  anImplementation << buffer;
          MACRO3_OUTOB(modul, spaceOrOperator);  anImplementation << buffer;
          MACRO9_OUTOB();  anImplementation << buffer;
        }
      } // End if tempo else.

      // Tempo or not tempo: 
      if(it->isTarget()){      
        MACRO3_VALSG(modul, 'E', YEPSI);  aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){         
          MACRO3_VALSGI(modul, 'E', YEPSI, w1);   aDeclaration << buffer;
        }
        MACRO3_SEPS(modul, spaceOrOperator);    anImplementation << buffer;
      }
      if(it->isNoward()){  
        sprintf (buffer, "Yao%s", modul);
        MACRO3_PTRMOD(buffer, modul, it->getStrYA1SpaceOperator().c_str(), it->getStrYA2SpaceOperator().c_str(), it->getStrYA3SpaceOperator().c_str());
        aDeclaration << buffer;
        MACRO3_CREY(modul, spaceOrOperator);      anImplementation << buffer;
      }
      else{      
        MACRO3_PTRMOD(modul, modul, it->getStrYA1SpaceOperator().c_str(), it->getStrYA2SpaceOperator().c_str(), it->getStrYA3SpaceOperator().c_str());
        aDeclaration << buffer;
        MACRO3_CREU(modul, spaceOrOperator);      anImplementation << buffer;
      }
      if(it->isCout() || it->isTarget()){      
        MACRO3_VALSG(modul, 'W', YWISH);    aDeclaration << buffer;
        for(w1=0; w1<it->getOutput() && w1<NB_MAX_MACRO; ++w1){               
          MACRO3_VALSGI(modul, 'W', YWISH, w1);     aDeclaration << buffer;
          MACRO3_HERESGI(modul, 'W', YWISH, w1);    aDeclaration << buffer;
        }
        MACRO3_SWISH(modul, spaceOrOperator);     anImplementation << buffer;
      }
    } // End dim 3.
  }   // End for each module.

  // Line 3462 Yao8.c    
  // SECOND PART: -------------------------------------------generation of GENERAL elements.
  // --------------------------------------------------------------------------------------

  // 2.-1.0) Creation of the functions YwishEQPstate_modul (complement to the first part).
  // --------------------------------------------------------------------------------------
  if(theContext.isGradTest())
    for(Table<Modul>::iterator mod=aModuleTable.begin(); mod != aModuleTable.end(); mod++){
      if(!mod->getCovt().empty() && mod->getCovt() != mod->getName()){  
        w2 = mod->getNbAxes();    // => w2 = is the dimension of the module: number of axes.
        if(mod->getTime()){       // Case tempo (for the out module).
               if(w2==1) MACRO1_WEQPST(mod->getName().c_str(), mod->getSpaceOrOperator().c_str());         
          else if(w2==2) MACRO2_WEQPST(mod->getName().c_str(), mod->getSpaceOrOperator().c_str());         
          else            MACRO3_WEQPST(mod->getName().c_str(), mod->getSpaceOrOperator().c_str());         
        }else{ // => Non tempo.
               if(w2==1) MACRO1_WEQPS(mod->getName().c_str(), mod->getSpaceOrOperator().c_str());         
               //if(w2==1) MACRO1_WEQPS(mod->getCovt().c_str(), mod->getSpaceOrOperator().c_str());         
          else if(w2==2) MACRO2_WEQPS(mod->getName().c_str(), mod->getSpaceOrOperator().c_str());         
          else            MACRO3_WEQPS(mod->getName().c_str(), mod->getSpaceOrOperator().c_str());         
        }
        anImplementation << buffer;
      }
    }
/*
  if(theContext.isGradTest())
    for(Table<Modul>::iterator mod=aModuleTable.begin(); mod != aModuleTable.end(); mod++){
      if(!mod->getCovt().empty() && mod->getCovt() != mod->getName()){  
        Modul *covt;
        covt = aModuleTable.find(mod->getCovt());
        w2 = covt->getNbAxes();   // => w2 = is the dimension of the covariance module: number of axes.
        if(covt->getTime()){      // Case tempo (for the out module).
               if(w2==1) MACRO1_WEQPST(covt->getName().c_str(), covt->getSpaceOrOperator().c_str());         
          else if(w2==2) MACRO2_WEQPST(covt->getName().c_str(), covt->getSpaceOrOperator().c_str());         
          else           MACRO3_WEQPST(covt->getName().c_str(), covt->getSpaceOrOperator().c_str());         
        }else{ // => Non tempo.
               if(w2==1) MACRO1_WEQPS(covt->getName().c_str(), covt->getSpaceOrOperator().c_str());         
          else if(w2==2) MACRO2_WEQPS(covt->getName().c_str(), covt->getSpaceOrOperator().c_str());         
          else           MACRO3_WEQPS(covt->getName().c_str(), covt->getSpaceOrOperator().c_str());         
        }
        anImplementation << buffer;
      }
    }

*/


  // 3.0.0) Creation of ... for m1qn3 (and m2qn1 if required).
  //---------------------------------------------------------
  aDeclaration << "#define  YSIZEPB   " << sizeM1qn3 << "//sum of the number of states (output) of all targets\n";
  if(theContext.isM1qn3()){ 
    aDeclaration << "\n//€ € € € FOR M1QN3 € € € € € € € € € € € € € € € € € € € € € € €\n"; 
    aDeclaration << "float   Y3x[YSIZEPB]; //table for the states of targets \n";
    aDeclaration << "float   Y3g[YSIZEPB]; //table for the gradients of targets\n";
    // Dimension of the zone rz.
    Y3SizeRz2=sizeM1qn3*(sizeM1qn3+9)/2; // rz dimension for m1qn2.
    Y3SizeRz3=4*sizeM1qn3 + atoi(theConstantTable.find(static_cast<string>("Y3_M"))->getText().c_str()) * (2*sizeM1qn3+1); // rz dimension for m1qn3.
    if(theContext.isM2qn1() && Y3SizeRz2>Y3SizeRz3) // If m2qn1 demanded, we take the max dimension between m2qn1 et m1qn3.
      aDeclaration << "#define Y3_SZ_RZ   " << Y3SizeRz2 << "  //rz dimension\n"; 
    else  aDeclaration << "#define Y3_SZ_RZ   " << Y3SizeRz3 << "  //rz dimension\n"; 
    aDeclaration << "float   Y3rz[Y3_SZ_RZ];\n";
    if(theContext.isM2qn1()){ 
      aDeclaration << "float         Y3xinf[YSIZEPB]; //down borne table of target's states \n";
      aDeclaration << "float   Y3xsup[YSIZEPB]; //up borne table of target's state \n";
      aDeclaration << "#define Y3_SZ_IZ   " <<  2*sizeM1qn3+1 << "  //iz dimension\n"; // m2qn1 is always >= m1qn3
      aDeclaration << "float   Y3dxmin[YSIZEPB]; //resolution table for the vector to be controlled \n";
    }else{ // Case only m1qn3.
      aDeclaration << "#define Y3_SZ_IZ   5  //iz dimension\n";  
      aDeclaration << "float   Y3dxmin[1]; //resolution scalar for the vector to be controlled \n";
    }
  }

  // 2.0.1) Creation d'objets globaux.
  //-------------------------------------------------
  aDeclaration << "\n/*------- GENERATION of global objects ------------------------*/\n";
  aDeclaration << "#define YSIZECO             " << sizeCout << " //size of modules cout (atempo)(event if not in order !)\n";
  aDeclaration << "#define YMAX_NBI        " << maxNbInput << " //max input number of a module \n";
  aDeclaration << "#define YMAX_NBS        " << maxNbOutput << " //max output number of a module\n";
  aDeclaration << "#define YMAX_JAC_NBI    " << maxNbJacobianInput  << " //max number of input for the jacobian (Yjac) \n";
  aDeclaration << "#define YMAX_JAC_NBS    " << maxNbJacobianOutput << " //max number of output for the jacobian (Yjac) \n";
  aDeclaration << setw(6) <<left<< theContext.getReal() << "  Yting[YMAX_NBI];                //max table for a global and common inputs number\n";
  aDeclaration << setw(6) <<left<< theContext.getReal() << "  Yjac[YMAX_JAC_NBS][YMAX_JAC_NBI]; //max table for a global and common jacobian\n";
  for(w1=0; w1<maxNbJacobianOutput && w1<NB_MAX_MACRO; ++w1)
    for(w2=0; w2<maxNbJacobianInput && w2<NB_MAX_MACRO; ++w2){ 
      aDeclaration << "#define YJ" << w1+1 << "I" << w2+1 << "  Yjac[" << w1 << "][" << w2 << "] \n";
    }
  aDeclaration << setw(6) <<left<< theContext.getReal() << "  Ytbeta[YMAX_NBI];               //max table of global and common beta\n";
 
  // For the parallelization
  if(theContext.isParallel()){
    aDeclaration << "#ifdef _OPENMP" << endl;
    aDeclaration << "#pragma omp threadprivate(Yting,Yjac,Ytbeta)  // Yting is a private global variable in the case of parallelism" << endl;
    aDeclaration << "#endif" << endl;
  } 


  // 2.0.2) Code concerning Neural Network (NN).
  //..............................................................
  if(theNeuronTable.size()){ // We generate a table of Neural Network.
    aDeclaration << "\n/*------- GENERATION D'UN TABLEAU d'ACCES AUX RNET --------*/\n";
    aDeclaration << "#define YNBNET         " << theNeuronTable.size() << " \n";
    aDeclaration << "struct Yst_netward YTabNet[" << theNeuronTable.size() << "] = {\n";
    for(Table<Neuron>::iterator it=theNeuronTable.begin(); it < theNeuronTable.end(); it++)
      aDeclaration << "\t{\"" << it->getName() << "\", 0, " << it->getInDegree() << ", " << it->getOutDegree() << ", 0, NULL, SigLin},\n";
    aDeclaration << "};\n";
    aDeclaration << "#include\t\t\"Dynnet.h\"\n";
  }
  // Line 3358 Yao8.c

  // 2.0.3) Creation of the structure of one obs (observation) in Y1.
  //----------------------------------------------------------------
  aDeclaration << "\n/*------- SOME OTHER AUTOMATIC GENERATION ------------------*/\n";
  if(theContext.isIncremental()){
    aDeclaration << "\nstruct Yst_obs {\n  int   time;\n  int   imod;\n  int   smod;\n  int   iaxe;";
    aDeclaration << "\n  int   jaxe;\n  int  kaxe;\n  YREAL vobs;\n  YREAL qtea;\n};";
  }
  else{ 
    aDeclaration << "\nstruct Yst_obs {\n  int   time;\n  int   imod;\n  int   smod;\n  int   iaxe;";
    aDeclaration << "\n  int   jaxe;\n  int   kaxe;\n  YREAL vobs;\n};";
  }
  aDeclaration << "\nstruct Yst_obs Yaobs;";
  aDeclaration << "\nint Yobs_insert(struct Yst_obs *aobs);\n";

  // 2.0.4) Necessary prototypes.
  //-------------------------------------------------------
  aDeclaration << "\n/*------- GENERATION of NECESSARY PROTOTYPES -------------*/\n";
  aDeclaration << theContext.getReal() << " Ycostdiff(" << theContext.getReal() << " dinov, " << theContext.getReal()<< " dcov);\n"; // Opera.

  // 2.1) Automatic creation of Yao modules.
  //-----------------------------------------------------------------------
  //(nb pour le moment : dans le meme Y1.h)
  aDeclaration << "\n/*------- AUTOMATIC GENERATION of YaoModul class ----------*/\n";
  createYaoModules(aDeclaration);
  // Line 3587 Yao8.c 
  // 2.2) prototypes of auto-fonctions, charles comment:
  // (est-ce vraiment toujours utile? --> utile pour les fonctions que l'on veut rendre accessibles au realisateur).
  //-----------------------------------------------------------------------------------------------------------------
  aDeclaration << "\n//€ € € € PROTOTYPES of AUTO-FUNCTIONS € € € € € € € € € € €\n";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
    aDeclaration << "void Yrazgrad_" << mod->getName() << "(); \nvoid Ysetstate_" << mod->getName() << "(); \n";
    if(mod->isTarget()){       
      aDeclaration << "void Ysetepsi_" << mod->getName() << "(); \nvoid Yadjust_" << mod->getName() << "(); \n";
      aDeclaration << "void Y3getstate_" << mod->getName() << "(float x[]); \nvoid Y3valstate_" << mod->getName() << "(); \nvoid Y3valgrad_" << mod->getName() << "(float g[]); ";
      if(theContext.isM2qn1())
        aDeclaration << "\nvoid Y3valxinf_" << mod->getName() << "(); \nvoid Y3valxsup_" << mod->getName() << "(); \nvoid Y3valdxmin_" << mod->getName() << "(); \n";
    }
  }

  // 2.3.1) Creation of the function Ycreate_all .........................
  anImplementation << "\nvoid Ycreate_all () \n{";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
    anImplementation << "\n\t Ycreate_" << mod->getName() << " ();";
  anImplementation << "\n}";

  // 2.3.2) Computation of cout and gradient; standard case.
  // Charles comment: que diff dans zone wish = state - obs.
  anImplementation << "\nvoid Ywishdiff_all (char *nmmod, int Yws, int Yw1, int Yw2, int Yw3, int Ywt, YREAL vobs) \n{\t";
  anImplementation << "\n\t if(1==0);";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){       
    if(mod->isCout() || mod->isTarget()){        
      anImplementation << "\n\t else if (strcmp(nmmod, \"" << mod->getName() << "\") == 0)";
      if(mod->getNbAxes()==1){      
        if(mod->getTime())              // Tempo.
          anImplementation << "\n\t\t\t\t YW_" << mod->getName() << "(Yws, Yw1) = YS_" << mod->getName() << "(Yws, Yw1, Ywt) - vobs;";
        else                        // Non tempo.
          anImplementation << "\n\t\t\t\t YW_" << mod->getName() << "(Yws, Yw1) = YS_" << mod->getName() << "(Yws, Yw1) - vobs;";
      }else if(mod->getNbAxes()==2){      
        if(mod->getTime())              // Tempo.
          anImplementation << "\n\t\t\t\t YW_" << mod->getName() << "(Yws, Yw1, Yw2) = YS_" << mod->getName() << "(Yws, Yw1, Yw2, Ywt) - vobs;";
        else                            // Non tempo. 
          anImplementation << "\n\t\t\t\t YW_" << mod->getName() << "(Yws, Yw1, Yw2) = YS_" << mod->getName() << "(Yws, Yw1, Yw2) - vobs;";
      }else if (mod->getNbAxes()==3){      
        if(mod->getTime())              // Tempo.
          anImplementation << "\n\t\t\t\t YW_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3) = YS_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3, Ywt) - vobs;";
        else         // Non tempo.
          anImplementation << "\n\t\t\t\t YW_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3) = YS_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3) - vobs;";
      }
    }
  }
  anImplementation << "\n}";

  // Computation of cout and gradient with the difference (wish = state - obs) of the module cout
  // and eventually also the result of the computation of covariance (Ystate of caltype B, R or K).
  anImplementation << "\nvoid Ycostwishdiff_all (char *nmmod, int Yws, int Yw1, int Yw2, int Yw3, int Ywt) \n{\t";
  anImplementation << "\n\t if(1==0);";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){       
    if(mod->isCout() || mod->isTarget()){  
      if(mod->getCovt() == mod->getName()) c1='W';      // The covt module is himself.
      else c1='S';                                      // The covt module is another module.
      anImplementation << "\n\t else if (strcmp(nmmod, \"" << mod->getName() << "\") == 0)";
      if(mod->getNbAxes()==1){      
        if(mod->getTime()){     // Tempo. 
          anImplementation  << "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1, Ywt) += Ycostdiff(YW_"
                            << mod->getName() << "(Yws, Yw1), Y" << c1 << "_" << mod->getCovt() << "(Yws, Yw1));";
        }else{              // Non tempo. 
          anImplementation  << "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1) += Ycostdiff(YW_"
                            << mod->getName() << "(Yws, Yw1), Y" << c1 << "_" << mod->getCovt() << "(Yws, Yw1));";
        }
      }else if (mod->getNbAxes()==2){      
        if(mod->getTime()){         // Tempo.
          anImplementation  << "\n\t\t\t\t      YG_" << mod->getName() << "(Yws, Yw1, Yw2, Ywt) += Ycostdiff(YW_"
                            << mod->getName() << "(Yws, Yw1, Yw2), Y" << c1 << "_" << mod->getCovt() << "(Yws, Yw1, Yw2));";
        }else{              // Non tempo.
          anImplementation  <<  "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1, Yw2) += Ycostdiff(YW_"
                            << mod->getName() << "(Yws, Yw1, Yw2), Y" << c1 << "_" << mod->getCovt() << "(Yws, Yw1, Yw2));";
        }
      }else if(mod->getNbAxes()==3){      
        if(mod->getTime()){    // Tempo.
          anImplementation  << "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3, Ywt) += Ycostdiff(YW_"
                            << mod->getName() << "(Yws, Yw1, Yw2, Yw3), Y" << c1 << "_" << mod->getCovt() << "(Yws, Yw1, Yw2, Yw3));"; 
        }else{            // Non tempo.
          anImplementation  << "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3) += Ycostdiff(YW_"
                            << mod->getName() << "(Yws, Yw1, Yw2, Yw3), Y" << c1 << "_" << mod->getCovt() << "(Yws, Yw1, Yw2, Yw3));";
        }
      }
    }
  } // End for.
  anImplementation << "\n}";

  if(theContext.isIncremental()){
    // Computation of cout and gradient; incremental case. Charles comment:
    // 1) calcul de : d* alias dstar i.e. la quantite adjointe (qtea)  qtea = f(Ygrad, Ystate, obs) =  M'(Xk).dx - (y° - M(Xk))
    // avec Ygrad=M'(Xk).dx : c'est le resultat du LT sur les points de calcul du cout 
    // Yo : ce sont les obs, et M(Xk) correspond aux etats i.e. a Ystate
    anImplementation << "\nvoid Yc_dstar_all (int indic, char *nmmod, int nout, int iaxe, int jaxe, ";
    anImplementation << "int kaxe, int apdt, int pdt, YREAL *vobs, YREAL *qtea) \n{\t\n\t if(1==0);";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){       
      if(mod->isCout() || mod->isTarget()){        
        anImplementation << "\n\t else if (strcmp(nmmod, \"" << mod->getName() << "\") == 0)";
        if(mod->getNbAxes()==1){      
          if(mod->getTime()){           // Tempo.
            anImplementation << "\n\t\t\t\t *qtea = YG_" << mod->getName() << "(nout, iaxe, pdt) - (*vobs - YS_";
            anImplementation << mod->getName() << "(nout, iaxe, pdt));";
          }else                         // Non tempo. 
            anImplementation << "\n\t\t\t\t *qtea = YG_" << mod->getName() << "(nout, iaxe) - (*vobs - YS_" << mod->getName() << "(nout, iaxe));";
        }else if(mod->getNbAxes()==2){      
          if(mod->getTime()){           // Tempo.
            anImplementation << "\n\t\t\t\t *qtea = YG_" << mod->getName();
            anImplementation << "(nout, iaxe, jaxe, pdt) - (*vobs - YS_" << mod->getName() << "(nout, iaxe,jaxe, pdt));";
          }else{                                //Non tempo. 
            anImplementation << "\n\t\t\t\t *qtea = YG_" << mod->getName();
            anImplementation << "(nout, iaxe, jaxe) - (*vobs - YS_" << mod->getName() << "(nout, iaxe, jaxe));";
          } 
        }else if(mod->getNbAxes()==3){      
          if(mod->getTime()){           // Tempo.
            anImplementation << "\n\t\t\t\t *qtea = YG_" << mod->getName();
            anImplementation << "s(nout, iaxe, jaxe, kaxe, pdt) - (*vobs - YS_" << mod->getName() << "(nout,iaxe, jaxe, kaxe, pdt));";
          }else{                            // Non tempo.
            anImplementation << "\n\t\t\t\t *qtea = YG_" << mod->getName();
            anImplementation << "(nout, iaxe, jaxe, kaxe) - (*vobs - YS_" << mod->getName() << "(nout, iaxe, jaxe, kaxe));";
          }
        }
      }
    }
    anImplementation << "\n}";

    // 2) Charles comment: que qtea (deja=grad-(obs-state)) dans zone wish.
    anImplementation << "\nvoid Ywishqtea_all (char *nmmod, int Yws, int Yw1, int Yw2, int Yw3, YREAL qtea) \n{\t";
    anImplementation << "\n\t if(1==0);";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){       
      if(mod->isCout() || mod->isTarget()){        
        anImplementation << "\n\t else if (strcmp(nmmod, \"" << mod->getName() << "\") == 0)";
        if(mod->getNbAxes()==1){      
          anImplementation << "\n\t\t\t\t YW_" << mod->getName() << "(Yws, Yw1) = qtea;";
        }else if(mod->getNbAxes()==2){      
          anImplementation << "\n\t\t\t\t YW_" << mod->getName() << "(Yws, Yw1, Yw2) = qtea;";
        }else if(mod->getNbAxes()==3){      
          anImplementation << "\n\t\t\t\t YW_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3) = qtea;";
        }
      }
    }
    anImplementation << "\n}";

    // Charles comment: calcul du cout et du gradient avec qtea (deja= deja=grad-(obs-state)) du module cout
    // et eventuellement aussi avec le resultat d'un calcul de covariance (Ystate de caltype B, R ou K).
    anImplementation << "\nvoid Ycostwishqtea_all (char *nmmod, int Yws, int Yw1, int Yw2, int Yw3, int Ywt, YREAL qtea) \n{\t";
    anImplementation << "\n\t if(1==0);";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){       
      if(mod->isCout() || mod->isTarget()){  
        if(mod->getCovt() == mod->getName()) c1='W';      // With himself.
        else c1='S';                                      // The covt module associated.
        anImplementation << "\n\t else if (strcmp(nmmod, \"" << mod->getName() << "\") == 0)";
        if(mod->getNbAxes()==1){      
          if(mod->getTime()){                 // Tempo. 
            anImplementation << "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1, Ywt) += Ycostdiff(qtea, Y";
            anImplementation << c1 << "_" << mod->getCovt() << "(Yws, Yw1));";
          }else{                                  // Non tempo. 
            anImplementation << "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1) += Ycostdiff(qtea, Y";
            anImplementation << c1 << "_" << mod->getCovt() << "(Yws, Yw1));";
          }
        }else if(mod->getNbAxes()==2){      
          if(mod->getTime()){                 // Tempo.
            anImplementation << "\n\t\t\t\t      YG_" << mod->getName() << "(Yws, Yw1, Yw2, Ywt) += Ycostdiff(qtea, Y";
            anImplementation << c1 << "_" << mod->getCovt() << "(Yws, Yw1, Yw2));";
          }else{                                      // Non tempo.
            anImplementation << "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1, Yw2) += Ycostdiff(qtea, Y";
            anImplementation << c1 << "_" << mod->getCovt() << "(Yws, Yw1, Yw2));";
          }
        }else if(mod->getNbAxes()==3){      
          if(mod->getTime()){                 // Tempo.
            anImplementation << "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3, Ywt) += Ycostdiff(qtea, Y";
            anImplementation << c1 << "_" << mod->getCovt() << "(Yws, Yw1, Yw2,Yw3));";
          }else{                                      // Non tempo.
            anImplementation << "\n\t\t\t\t YG_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3) += Ycostdiff(qtea, Y";
            anImplementation << c1 << "_" << mod->getCovt() << "(Yws, Yw1, Yw2, Yw3));";
          }
        }
      }
    }
    anImplementation << "\n}";
  }// End incremental.

  // 2.3.3) Creation of the function Youtoobs_mod for the Observations.
  anImplementation << "\nvoid Youtoobs_mod(YioKind yiokind, char *nmmod, int numout, int pdt, int arbpdt)\n{\n \t if(1==0);";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){       
    if(mod->isCout() || mod->isTarget()){
      anImplementation << "\n \t else if (strcmp(nmmod, \"" << mod->getName(); 
      anImplementation << "\") == 0) Youtoobs_" << mod->getName() << "(yiokind, numout, pdt, arbpdt);";
    }
  }
  anImplementation << "\n}";

  // 2.3.4) Creation of the des functions Yadjust*_all ...........................
  // 2.3.4.1) Standard case: Yadjust_all : correction of states: state -= epsi*grad.
  anImplementation << "\nvoid Yadjust_all () \n{";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){       
    if(mod->isTarget())
      anImplementation << "\n\t Yadjust_" << mod->getName() << " ();";
  }
  anImplementation << "\n}";

  // Line 3936 Yao8.c 
  if(theContext.isIncremental()){
    // 2.3.4.2) Incremental case: Yadjustd_all : correction of dx : delta -= epsi*grad (internal loop).
    anImplementation << "\nvoid Yc_adjustd_all () \n{";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)       
      if(mod->isTarget())       
        anImplementation << "\n\t Yc_adjustd_" << mod->getName() << " ();";
    anImplementation << "\n}";
    // 2.3.4.3) Incremental case: Yadjustkall : states corrections : state += delta ; state(k+1) = state(k) + delta.
    anImplementation << "\nvoid Yc_adjustk_all () \n{";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)       
      if (mod->isTarget())
        anImplementation << "\n\t Yc_adjustk_" << mod->getName() << " ();";
    anImplementation << "\n}";
  } // End incremental.

  // 2.3.5) Creation of the function Yrazgrad_all ........................
  anImplementation << "\nvoid Yrazgrad_all () \n{";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)       
    anImplementation << "\n\t Yrazgrad_" << mod->getName() << " ();";
  anImplementation << "\n}";

  // 2.3.6) Creation of the function Yrazgrad_only .......................
  // Multi: we consider the trajectory!
  anImplementation <<  "\nvoid Yrazgrad_only (int itraj) \n{";
  for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
    anImplementation << "\n\tif (itraj==Yid_" << tra->getName() << ")\n\t{";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
      if(mod->getTime() == 0 && !mod->isNoward())     
        if(mod->getTrajectory() == tra->getName())
          anImplementation << "  Yrazgrad_" << mod->getName() << " ();\n\t ";
    anImplementation << "}";
  }
  anImplementation << "\n}";

  //2.3.7) Creation of the function Ysetstate_mod .......................
  // Charles comment: (nb: etait auparavent pris en charge par auto_call).
  anImplementation << "\nint Ysetstate_mod (char *nmmod, YREAL val) \n{\tint codret=0; int all=0;\n\tif (!strcmp(nmmod, \"Y#A\")) all=1;";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
    anImplementation << "\n\tif (!strcmp(nmmod, \"" << mod->getName() << "\") || all)\n\t{  Ysetstate_" << mod->getName() << "(val);codret=1;}";
  anImplementation << "\n\treturn(codret);\n}";

  // 2.3.8) Creation of the function Ysetwish_mod ........................
  anImplementation << "\nvoid Ysetwish_mod (int imod, YREAL val) \n{\tif(1==0);";
  w1=0;
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++, w1++)
    if(mod->isCout() || mod->isTarget())
      anImplementation << "\n\telse if (imod==" << w1 << ") Ysetwish_" << mod->getName() << "(val);";
  anImplementation << "\n}";

  // 2.3.9) Creation of the function of i/o for each module ...............
  anImplementation << "\nvoid  Yio_mod (char *nmmod, int Yws, int Yw1, int Yw2, int Yw3, int Ywt, " << theContext.getReal() << " val)\n{";
  anImplementation << "\n\t if(1==0);";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
    anImplementation << "\n\t else if (strcmp(nmmod, \"" <<mod->getName()<< "\") == 0) Yio_" << mod->getName() << "(Yws, Yw1, Yw2, Yw3, Ywt, val);";
  anImplementation << "\n}";

  // 2.3.10) YgradCTOtab_all (+with target on trajectory ) (+Cumul for basic internal loop).
  anImplementation << "\nvoid YgradCTOtab_target (YREAL tab[]) \n{";
  anImplementation << "\t//Y3windice = 0;"; 
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
    if(mod->isTarget()){   
      if(mod->getTime()){
        anImplementation  << "\n\t YgradCTOtab_" << mod->getName() << " (YTabMod[Yid_" << mod->getName() 
                          << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, tab);";
      }else anImplementation << "\n\t YgradCTOtab_" << mod->getName() << " (tab);";
    }
  anImplementation << "\n}";
  // 2.3.11) YtabTOgrad_target (+with target on trajectory) (+tab TO grad of target for basic internal loop).
  anImplementation << "\nvoid YtabTOgrad_target (YREAL tab[]) \n{";
  anImplementation << "\t//Y3windice = 0;";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
    if(mod->isTarget()){   
      if(mod->getTime()){
        anImplementation  << "\n\t YtabTOgrad_" << mod->getName() << " (YTabMod[Yid_" << mod->getName() 
                          << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, tab);";
      }else anImplementation << "\n\t YtabTOgrad_" << mod->getName() << " (tab);";
    }
  anImplementation << "\n}";

  // 2.3.12) Creation of functions Y3..._all pour m1qn3 : ..............
  if(theContext.isM1qn3()){
    // 2.3.12.1) Creation of the function Y3getstate_all. 
    anImplementation << "\nvoid Y3getstate_all (float x[]) \n{\t Y3windice = 0;";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)       
      if(mod->isTarget())
        anImplementation << "\n\t Y3getstate_" << mod->getName() << " (x);";
    anImplementation << "\n}";

    // 2.3.12.2) Creation of the function Y3valstate_all.
    anImplementation << "\nvoid Y3valstate_all () \n{\t Y3windice = 0;";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
      if(mod->isTarget())
        anImplementation << "\n\t Y3valstate_" << mod->getName() << " ();";
    anImplementation << "\n}";

    // 2.3.12.3) Creation of the function Y3valgrad_all.
    anImplementation << "\nvoid Y3valgrad_all (float g[]) \n{\t Y3windice = 0;";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
      if(mod->isTarget())
        anImplementation << "\n\t Y3valgrad_" << mod->getName() << " (g);";
    anImplementation << "\n}";

    if(theContext.isM2qn1()){       
      // 2.3.12.4) Creation of the function Y3valxinf_all.
      anImplementation << "\nvoid Y3valxinf_all () \n{\t Y3windice = 0;";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)       
        if(mod->isTarget())
          anImplementation << "\n\t Y3valxinf_" << mod->getName() << " ();";
      anImplementation << "\n}";

      // 2.3.12.5) Creation of the function Y3valxsup_all.
      anImplementation << "\nvoid Y3valxsup_all () \n{\t Y3windice = 0;";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
        if(mod->isTarget())
          anImplementation << "\n\t Y3valxsup_" << mod->getName() << " ();";
      anImplementation << "\n}";

      // 2.3.12.6) Creation of the function Y3valdxmin_all. 
      anImplementation << "\nvoid Y3valdxmin_all () \n{\t Y3windice = 0;";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
        if(mod->isTarget())
          anImplementation << "\n\t Y3valdxmin_" << mod->getName() << " ();";
      anImplementation << "\n}";
    }

    if(theContext.isIncremental()){
      // 2.3.12.7) Creation of the function Y3getdelta_all.
      anImplementation << "\nvoid Y3getdelta_all (float x[]) \n{\t Y3windice = 0;";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
        if(mod->isTarget())
          anImplementation << "\n\t Y3getdelta_" << mod->getName() << " (x);";
      anImplementation << "\n}";

      // 2.3.12.8) Creation of the function Y3valdelta_all.
      anImplementation << "\nvoid Y3valdelta_all () \n{\t Y3windice = 0;";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
        if(mod->isTarget())
          anImplementation <<  "\n\t Y3valdelta_" << mod->getName() << " ();";
      anImplementation << "\n}";
    } // End incremental.
  }   // End M1QN3.
  // Line 4122 Charles.

  if(theContext.isIncremental()){
    // 2.3.13) Creation of affectation functions .......................
    // 2.3.13.1: YdeltaEQPCstate_all (with multi).
    anImplementation << "\nvoid YdeltaEQPCstate_traj(int itraj, char *norkmod, int frompdt, int topdt) \n{";
    anImplementation << "\n\tif (1==0){}";
    for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
      anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->getTrajectory() == tra->getName()){  
          if(mod->isTarget() || theContext.isGradTest()){    
            norkmod(anImplementation, mod); // norkmod : test of the name and the kind of module: "Y#T": Target, "Y#C": Cout, "Y#A": All.
            if(mod->getTime())
              anImplementation << "\n\t YdeltaEQPstate_" << mod->getName() << " (frompdt, topdt, YTabMod[Yid_" << mod->getName() << "].pcoef);";
            else anImplementation << "\n\t YdeltaEQPstate_" << mod->getName() << " (0, 1, YTabMod[Yid_" << mod->getName() << "].pcoef);";
          }
        }
      }
      anImplementation << "\n\t}";
    }
    anImplementation << "\n}";

    // 2.3.13.2: YdeltaEQPCstate_all (with target on trajectory).
    anImplementation << "\nvoid YdeltaEQPCstate_target() \n{";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
      if(mod->isTarget())
        if(mod->getTime()){
          anImplementation << "\n\t YdeltaEQPstate_" << mod->getName() << " (YTabMod[Yid_" << mod->getName() << "].deb_target, YTabMod[Yid_";
          anImplementation << mod->getName() << "].end_target, YTabMod[Yid_" << mod->getName() << "].pcoef);";
        }else anImplementation << "\n\t YdeltaEQPstate_" << mod->getName() << " (0, 1, YTabMod[Yid_" << mod->getName() << "].pcoef);";
    }
    anImplementation << "\n}";

    // 2.3.13.3: YgradEQPdelta_all (with multi).
    anImplementation << "\nvoid YgradEQPdelta_traj(int itraj, char *norkmod, int frompdt, int topdt, double pfact) \n{";
    anImplementation << "\n\tif (1==0){}";
    for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
      anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->getTrajectory() == tra->getName()){  
          if(mod->isTarget() || theContext.isGradTest()){    
            norkmod(anImplementation, mod); // norkmod : test of the name and the kind of module: "Y#T": Target, "Y#C": Cout, "Y#A": All.
            if(mod->getTime())
              anImplementation << "\n\t YgradEQPdelta_" << mod->getName() << " (frompdt, topdt, pfact);";
            else anImplementation << "\n\t YgradEQPdelta_" << mod->getName() << " (0, 1, pfact);";
          }
        }
      }
      anImplementation << "\n\t}";
    }
    anImplementation << "\n}";
    // 2.3.13.4: YgradEQPdelta_all (with target on trajectory).
    anImplementation << "\nvoid YgradEQPdelta_target(double pfact) \n{";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
      if(mod->isTarget()){ 
        if(mod->getTime()){
          anImplementation << "\n\t YgradEQPdelta_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
          anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, pfact);";
        }else anImplementation << "\n\t YgradEQPdelta_" << mod->getName() << " (0, 1, pfact);";
      }
    }
    anImplementation << "\n}";

    // 2.3.13.5: YgradEQval_all (multi: we consider the trajectory!).
    anImplementation << "\nvoid YgradEQval_traj(int itraj, char *norkmod, int frompdt, int topdt, double val) \n{";
    anImplementation << "\n\tif (1==0){}";
    for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
      anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->getTrajectory() == tra->getName()){  
          norkmod(anImplementation, mod);  // norkmod : test of the name and the kind of module: "Y#T": Target, "Y#C": Cout, "Y#A": All.
          if(mod->getTime())
            anImplementation << "\n\t\t YgradEQval_" << mod->getName() << " (frompdt, topdt, val);";
          else anImplementation << "\n\t\t YgradEQval_" << mod->getName() << " (val);";
        }
      }
      anImplementation << "\n\t}";
    }
    anImplementation << "\n}";
  } // End of incremental.
  // Line 4229 Charles.

  if(theContext.isTool()){
    if(theContext.isGradTestOrIncremental()){
      // 2.3.13.6: YdeltaEQPstate_all(frompdt, topdt, pfact) (with multi).
      anImplementation << "\nvoid YdeltaEQPstate_traj(int itraj, char *norkmod, int frompdt, int topdt, double pfact) \n{";
      anImplementation << "\n\tif (1==0){}";
      for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
        anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
        for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
          if(mod->getTrajectory() == tra->getName()){  
            if(mod->isTarget() || theContext.isGradTest()){  
              norkmod(anImplementation, mod); 
              if(mod->getTime())
                anImplementation << "\n\t YdeltaEQPstate_" << mod->getName() << " (frompdt, topdt, pfact);";
              else anImplementation << "\n\t YdeltaEQPstate_" << mod->getName() << " (0, 1, pfact);";
            }
          }
        }
        anImplementation << "\n\t}";
      }
      anImplementation << "\n}";

      // 2.3.13.7: YdeltaEQPstate_all(frompdt, topdt, pfact) (with target on trajectory).
      anImplementation << "\nvoid YdeltaEQPstate_target(double pfact) \n{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->isTarget()){  
          if(mod->getTime()){
            anImplementation << "\n\t YdeltaEQPstate_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
            anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, pfact);";
          }else anImplementation << "\n\t YdeltaEQPstate_" << mod->getName() << " (0, 1, pfact);";
        }
      }
      anImplementation << "\n}";
      
      anImplementation << "\nvoid YdeltaEQPgrad_target(double pfact) \n{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->isTarget()){  
          if(mod->getTime()){
            anImplementation << "\n\t YdeltaEQPgrad_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
            anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, pfact);";
          }else anImplementation << "\n\t YdeltaEQPgrad_" << mod->getName() << " (0, 1, pfact);";
        }
      }
      anImplementation << "\n}";

      // 2.3.13.8: YstateEQPdelta_all(frompdt, topdt, pfact) (with multi).
      anImplementation << "\nvoid YstateEQPdelta_traj(int itraj, char *norkmod, int frompdt, int topdt, double pfact) \n{";
      anImplementation << "\n\tif (1==0){}";
      for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
        anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
        for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
          if(mod->getTrajectory() == tra->getName()){  
            if(mod->isTarget() || theContext.isGradTest()){  
              norkmod(anImplementation, mod);  
              if(mod->getTime())
                anImplementation << "\n\t YstateEQPdelta_" << mod->getName() << " (frompdt, topdt, pfact);";
              else anImplementation << "\n\t YstateEQPdelta_" << mod->getName() << " (0, 1, pfact);";
            }
          }
        }
        anImplementation << "\n\t}";
      }
      anImplementation << "\n}";

      // 2.3.13.9: YstateEQPdelta_all(frompdt, topdt, pfact) (with target sur trajectoire).
      anImplementation << "\nvoid YstateEQPdelta_target(double pfact) \n{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->isTarget()){        
          if(mod->getTime()){
            anImplementation << "\n\t YstateEQPdelta_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
            anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, pfact);";
          }else anImplementation << "\n\t YstateEQPdelta_" << mod->getName() << " (0, 1, pfact);";
        }
      }
      anImplementation << "\n}";

      anImplementation << "\nvoid YstateEQPOdelta_target(double pfact, char *codop) \n{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->isTarget()){        
          if(mod->getTime()){
            anImplementation <<  "\n\t YstateEQPOdelta_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
            anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, pfact, codop);";
          }else anImplementation << "\n\t YstateEQPOdelta_" << mod->getName() << " (0, 1, pfact, codop);";
        }
      }
      anImplementation <<  "\n}";
      
      anImplementation << "\nvoid YstateEQAPTdelta_target(double pfact, YREAL tab[]) \n{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->isTarget()){        
          if(mod->getTime()){
            anImplementation << "\n\t YstateEQAPTdelta_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
            anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, pfact,tab);";
          }else anImplementation << "\n\t YstateEQAPTdelta_" << mod->getName() << " (0, 1, pfact, tab);";
        }
      }
      anImplementation << "\n}";
    } // End of if gradTestAndIncremental.

    // 2.3.13.10: YgradEQPstate_all(frompdt, topdt, pfact) (with multi).
    anImplementation << "\nvoid YgradEQPstate_traj(int itraj, char *norkmod, int frompdt, int topdt, double pfact) \n{";
    anImplementation << "\n\tif (1==0){}";
    for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
      anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->getTrajectory() == tra->getName()){  
          norkmod(anImplementation, mod);  
          if(mod->getTime())
            anImplementation << "\n\t YgradEQPstate_" << mod->getName() << " (frompdt, topdt, pfact);";
          else anImplementation << "\n\t YgradEQPstate_" << mod->getName() << "(pfact);";
        }
      }
      anImplementation << "\n\t}";
    }
    anImplementation << "\n}";

    // 2.3.13.11: YgradEQPstate_all(frompdt, topdt, pfact) (with target on trajectory).
    anImplementation << "\nvoid YgradEQPstate_target(double pfact) \n{";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
      if(mod->isTarget()){
        if(mod->getTime()){
          anImplementation << "\n\t YgradEQPstate_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
          anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, pfact);";
        }else anImplementation << "\n\t YgradEQPstate_" << mod->getName() << " (pfact);";
      }
    }
    anImplementation << "\n}";
    
    anImplementation << "\nvoid YgradEQPOstate_target(double pfact, char *codop) \n{";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
      if(mod->isTarget()){
        if(mod->getTime()){
          anImplementation << "\n\t YgradEQPOstate_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
          anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, pfact, codop);";
        }else anImplementation << "\n\t YgradEQPOstate_" << mod->getName() << " (pfact, codop);";
      }
    }
    anImplementation << "\n}";

    // 2.3.13.12: YstateTOtab_all (with multi).
    anImplementation << "\nvoid YstateTOtab_traj (int itraj, char *norkmod, int frompdt, int topdt, YREAL tab[]) \n{";
    anImplementation << "\t//Y3windice = 0;"; 
    anImplementation << "\n\tif (1==0){}";
    for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
      anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->getTrajectory() == tra->getName()){  
          norkmod(anImplementation, mod);  
          if(mod->getTime())
            anImplementation << "\n\t YstateTOtab_" << mod->getName() << " (frompdt, topdt, tab);";
          else anImplementation << "\n\t YstateTOtab_" << mod->getName() << " (tab);";
        }
      }
      anImplementation << "\n\t}";
    }
    anImplementation << "\n}";

    // 2.3.13.13: YstateTOtab_all (with target with trajectory).
    anImplementation << "\nvoid YstateTOtab_target (YREAL tab[]) \n{";
    anImplementation << "\t//Y3windice = 0;"; 
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
      if(mod->isTarget()){
        if(mod->getTime()){
          anImplementation << "\n\t YstateTOtab_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
          anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, tab);";
        }else anImplementation << "\n\t YstateTOtab_" << mod->getName() << " (tab);";
      }
    }
    anImplementation << "\n}";

    // 2.3.13.14: YgradTOtab_all (with multi).
    anImplementation << "\nvoid YgradTOtab_traj (int itraj, char *norkmod, int frompdt, int topdt, YREAL tab[]) \n{";
    anImplementation << "\t//Y3windice = 0;";
    anImplementation << "\n\tif (1==0){}";
    for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
      anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->getTrajectory() == tra->getName()){  
          norkmod(anImplementation, mod);  
          if(mod->getTime())
            anImplementation << "\n\t YgradTOtab_" << mod->getName() << " (frompdt, topdt, tab);";
          else anImplementation << "\n\t YgradTOtab_" << mod->getName() << " (tab);";
        }
      }
      anImplementation << "\n\t}";
    }
    anImplementation << "\n}";

    // 2.3.13.15: YgradTOtab_all (with target on trajectory).
    anImplementation << "\nvoid YgradTOtab_target (YREAL tab[]) \n{";
    anImplementation << "\t//Y3windice = 0;";
    for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
      if(mod->isTarget()){
        if(mod->getTime()){
          anImplementation << "\n\t YgradTOtab_" << mod->getName() << " (YTabMod[Yid_" << mod->getName();
          anImplementation << "].deb_target, YTabMod[Yid_" << mod->getName() << "].end_target, tab);";
        }else anImplementation << "\n\t YgradTOtab_" << mod->getName() << " (tab);";
      }
    }
    anImplementation << "\n}";

    // 2.3.13.16: YtabTOgrad_all (with multi).
    anImplementation << "\nvoid YtabTOgrad_traj (int itraj, char *norkmod, int frompdt, int topdt, YREAL tab[]) \n{";
    anImplementation << "\t//Y3windice = 0;";
    anImplementation << "\n\tif (1==0){}";
    for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
      anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->getTrajectory() == tra->getName()){  
          norkmod(anImplementation, mod);  
          if(mod->getTime())
            anImplementation << "\n\t\t\t YtabTOgrad_" << mod->getName() << " (frompdt, topdt, tab);";
          else anImplementation << "\n\t\t\t YtabTOgrad_" << mod->getName() << " (tab);";
        }
      }
      anImplementation << "\n\t}";
    }
    anImplementation << "\n}";
  } // End of O_TOOL.
  // Line 4483 Charles.

  // 2.3.14) Generation of the Ydfward_all function, is the computation of the test concerning the gradient.
  if(theContext.isGradTest())
    dfwardAllGenerator(anImplementation);

  // 2.3.15) Creation of function calls to wishEQPstate for each trajectory (pour les amonts de covariance).
  if(theContext.isGradTest()){
    anImplementation << "\nvoid YwishEQPstate_traj_tocov (int itraj, int pdt, double pfact) \n{";
    anImplementation << "\n\tif (1==0){}";
    for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
      anImplementation << "\n\telse if (itraj==Yid_" << tra->getName() << ")\n\t{";
      for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
        if(mod->getTrajectory() == tra->getName()){  
          if(!mod->getCovt().empty() && mod->getCovt() != mod->getName()){  
            if(mod->getTime())
              anImplementation << "\n\t YwishEQPstate_" << mod->getName() << " (pdt, pfact);";
            else anImplementation << "\n\t YwishEQPstate_" << mod->getName() << " (pfact);";
          }
        }
      }
      anImplementation << "\n\t}";
    }
    anImplementation << "\n}";
  }

  // 2.3.16) Creation of the function Yauto_call.....
  anImplementation << "\nint Yauto_call (int argc, char *argv[]) \n{\n\t int codret=0; int all=0; " << theContext.getReal() << " val;";
  anImplementation << "\n\t if (1==0);";

  // 2.3.16.1 : setepsi.
  anImplementation << "\n\t else if ( !strcmp(argv[0], \"setepsi\") || !strcmp(argv[0], \"SETEPSI\") \n\t\t\t\t\t ||";
  anImplementation << "!strcmp(argv[0], \"setepsi_all\") || !strcmp(argv[0], \"SETEPSI_ALL\"))\n\t {";
  anImplementation << "\n\t\t\t if (!strcmp(argv[0], \"setepsi_all\") || !strcmp(argv[0], \"SETEPSI_ALL\"))";
  anImplementation << "{all=1; val=atof(argv[1]);} else val=atof(argv[2]);";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
    if(mod->isTarget()){
      anImplementation << "\n\t\t\t if (!strcmp(argv[1], \"" << mod->getName() << "\") || all)\n\t\t\t\t\t {Ysetepsi_";
      anImplementation << mod->getName() << "(val);codret=1;}";
    }
  anImplementation << "\n\t }";

  // 2.3.16.2 : netload for NN (Neuron Net).
  if(theContext.isNetward()){
    anImplementation << "\n\t else if (!strcmp(argv[0], \"netload\") || !strcmp(argv[0], \"NETLOAD\"))\n\t {";
    anImplementation << "\n\t\t\t codret=1;\n\t\t\t if (1==0);";
    for(Table<Neuron>::iterator neuron=theNeuronTable.begin(); neuron != theNeuronTable.end(); neuron++){
      anImplementation << "\n\t\t\t else if (!strcmp(argv[1], \"" << neuron->getName() << "\"))\n\t\t\t\t\t Ynetload_";
      anImplementation << neuron->getName() << "(argc, argv);";
    }
    anImplementation << "\n\t\t\t else codret=0;\n\t }";
  }
  anImplementation  << "\n\t else codret=0;\n\t return(codret);\n}\n";
  // Line 4551 Charles.
}// END function generate code for module--------------------------------------------------------------------------------------


/**
 * Method for the creation of YaoModules in the generated file.
 * @param aDeclaration is the generated file we are writing on.
 */
void Translator::createYaoModules(ostream& aDeclaration){
  string space, module, traj;             // Names of the actual space, module and trajectory.
  int w1, w2;                             // Some useful counters.
  ostringstream bufwrk;                   // A stream buffer to perform some work with strings.
  ostringstream streamInputWardFunctions; // It's useful in order to generate the string inputWardFunctions.
  string inputWardFunctions;              // Parameters in input for functions *ward.

  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
    // Some initialization for each module.
    module = mod->getName();
    space = mod->getSpaceOrOperator();
    traj = mod->getTrajectory();

    if(mod->isCloned()){       
      aDeclaration << "\n//////////// HERE IS A CLONE MODULE ////////////\n";
      if(mod->isNoward())
        aDeclaration << "class \t Yao" << module << ":public Yao" << mod->getCloned() << "{};\n";
      else aDeclaration << "class \t " << module << ":public " << mod->getCloned() << "{};\n";
      continue; // For a cloned module that's all!
    }
    bufwrk.str("");  
    if(mod->isTempo())
      bufwrk << "[YNBALLTIME_" << traj <<"]";
    // 1) Declaration of the Class variables.
    aDeclaration << "\n//////////// Begin of the Yao Class Yao" << module << " ////////////\n";
    aDeclaration << "class   \t      Yao" << module << "\n{\n\t public:\n";
    aDeclaration << "\t      " << theContext.getReal() << "\t " << YSTATE << bufwrk.str() << "[YNBS_" << module << "];\n";
    aDeclaration << "\t      " << theContext.getReal() << "\t " << YGRAD << bufwrk.str() << "[YNBS_" << module << "];\n";
    if(mod->isTarget())
      aDeclaration << "\t      " << theContext.getReal() << "\t " << YEPSI << "[YNBS_" << module << "];\n";
    if(mod->isCout() || mod->isTarget())
      aDeclaration << "\t      " << theContext.getReal() << "\t " << YWISH << "[YNBS_" << module << "];\n";
    if(theContext.isIncremental() && !theContext.isGradTest())
      if(mod->isTarget())
        if(mod->isTempo()){  
          if(mod->getEndTarget() == theTrajectoryTable.find(traj)->getBoot()) 
            // Case target on uptime.
            aDeclaration << "\t      " << theContext.getReal() << "\t " << YDELTA << "[YNBUPTIME_" << traj << "][YNBS_" << module << "];\n";
          else // Case target on steptime or alltime, we allocate on alltime in order to not have troubles for shift on the trajectory index.
            aDeclaration << "\t      " << theContext.getReal() << "\t " << YDELTA << "[YNBALLTIME_" << traj << "][YNBS_" << module << "];\n";
        }else aDeclaration << "\t      " << theContext.getReal() << "\t " << YDELTA << "[1][YNBS_" << module << "];\n";

    if(theContext.isGradTest()){        
      if(mod->isNoward()){  
        if(mod->isTempo())
          aDeclaration << "\t      " << theContext.getReal() << "\t " << YDELTA << "[YNBALLTIME_" << traj << "][YNBS_" << module << "];\n";
        else aDeclaration << "\t      " << theContext.getReal() << "\t " << YDELTA << "[1][YNBS_" << module << "];\n";
      }else // =>is ward.
        aDeclaration << "\t      " << theContext.getReal() << "\t " << YDELTA << "[YNBALLTIME_" << traj << "][YNBS_" << module << "];\n";
    }

    // 2) Constructor - Destructor and end of the class.
    aDeclaration <<  "\n//:=========> Constructor - Destructor ============\n";
    aDeclaration << "Yao" << module << "(){}\n~Yao" << module << "(){}\n\n};\n";

    // 3) Prototypes automatic generation of the not specific classes (non spec).
    streamInputWardFunctions.str("");
    inputWardFunctions = "";
    if(!mod->isSpec()){
      if(mod->isAutonet()){        
        if(mod->isTempo())
          MACRO0_PCLANT(module.c_str(), mod->getAutonet().c_str());     // Case of AutoNet Tempo.
        else MACRO0_PCLAN(module.c_str(), mod->getAutonet().c_str());   // Case of AutoNet non Tempo.
      }else if(!mod->isNoward()){ // Not useful for noward
        if(!mod->isArray()){        
          for(w1=0; w1<mod->getInput(); ++w1){
            streamInputWardFunctions << theContext.getReal() << " x" << w1 << ",";
            inputWardFunctions = streamInputWardFunctions.str();
            if(inputWardFunctions.size())
              inputWardFunctions.replace(inputWardFunctions.size()-1, 1, "");
          }
        }
        if(mod->isNetward())
          MACRO0_PCLNW(module.c_str(), inputWardFunctions.c_str());         // Case netward.
        else MACRO0_PCL(module.c_str(), inputWardFunctions.c_str());        
      } 
      if(!mod->isNoward()) // Not useful for noward.
        aDeclaration << buffer;
    }
  } // End for.
}

/**
 * Is a method for the generation of the test of the name and the kind of module: "Y#T": Target, "Y#C": Cout, "Y#A": All.
 * Repetitive generation of code for the utilities functions.
 * @param anImplementation is the generated file we are writing on.
 * @param mod is the module who we are interested on.
 */
void Translator::norkmod(ostream& anImplementation, Table<Modul>::iterator mod){
  anImplementation << "\n\t\tif ( !strcmp(norkmod, \"" << mod->getName() << "\") || !strcmp(norkmod, \"Y#A\") ";
  if(mod->isTarget())       
    anImplementation << "|| !strcmp(norkmod, \"Y#T\") ";
  if(mod->isCout())
    anImplementation << "|| !strcmp(norkmod, \"Y#C\") ";
  anImplementation << ")";
}

/**
 * Allows the generation of the Ydfward_all function that is: computation of the test concerning the gradient.
 * @param anImplementation is the generated file we are writing on.
 */
// gendfward_all for Yao8.c
void Translator::dfwardAllGenerator(ostream& anImplementation){
  int   w1;     // Just a counter.
  string mName; // The name of the current module.
  anImplementation << "\n int Ydfward_all(int modop, char *nmmod, int All, int KeKo,  float pdx, float ptol)\n{\n\tint nbko=0;\n";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
    mName = mod->getName();
    if(mod->getInput() && mod->getOutput() && !mod->isNetward() && !mod->isAutonet() && !mod->isNoward() && !mod->isHidjac()){       
      anImplementation << "\tif ( !strcmp(nmmod, \"" << mName << "\") || All )";
      if(mod->getNbAxes() == 1){                       
        if(mod->getTime()){
          anImplementation << "\n\t\tnbko += Ytestdf_" << mName << "(modop,KeKo,pdx,ptol,YNBI_" << mName << ",YNBS_";
          anImplementation << mName << ",\"" << mName << "\",Yting,Y" << mName << "[Yi]->Ystate[0],Y" << mName << "[Yi]);\n";
        }else {
          anImplementation << "\n\t\tnbko += Ytestdf_" << mName << "(modop,KeKo,pdx,ptol,YNBI_" << mName << ",YNBS_";
          anImplementation << mName << ",\"" << mName << "\",Yting,Y" << mName << "[Yi]->Ystate,Y" << mName << "[Yi]);\n";
        }
      }else if(mod->getNbAxes() == 2){                       
        if(mod->getTime()){
          anImplementation << "\n\t\tnbko += Ytestdf_" << mName << "(modop,KeKo,pdx,ptol,YNBI_" << mName << ",YNBS_";
          anImplementation << mName << ",\"" << mName << "\",Yting,Y" << mName << "[Yi][Yj]->Ystate[0],Y" << mName << "[Yi][Yj]);\n";
        }else{ 
          anImplementation << "\n\t\tnbko += Ytestdf_" << mName << "(modop,KeKo,pdx,ptol,YNBI_" << mName << ",YNBS_";
          anImplementation << mName << ",\"" << mName << "\",Yting,Y" << mName << "[Yi][Yj]->Ystate,Y" << mName << "[Yi][Yj]);\n";
        }
      }else if(mod->getNbAxes() == 3){                       
        if(mod->getTime()){
          anImplementation << "\n\t\tnbko += Ytestdf_" << mName << "(modop,KeKo,pdx,ptol,YNBI_" << mName << ",YNBS_";
          anImplementation << mName << ",\"" << mName << "\",Yting,Y" << mName << "[Yi][Yj][Yk]->Ystate[0],Y" << mName << "[Yi][Yj][Yk]);\n";
        }else {
          anImplementation << "\n\t\tnbko += Ytestdf_" << mName << "(modop,KeKo,pdx,ptol,YNBI_" << mName << ",YNBS_";
          anImplementation << mName << ",\"" << mName << "\",Yting,Y" << mName << "[Yi][Yj][Yk]->Ystate,Y" << mName << "[Yi][Yj][Yk]);\n";
        }
      }
    }
  }
  anImplementation << "\treturn(nbko);\n}\n";
}

/**
 * For the Connection directive we have not to generate code but we leave this name to this member for continuity.
 * We perform some check and we manipulate the information of the table Connection.
 * At the end of this method in theConnectionTable we will have a simple connection for each element of the Table (before this method we could have
 * more connection in the same table entry caused from the range operators: "%" or "#" in the ctin-m directive.
 * Having one simple connection for each Table entry is more practical in the future order generation.
 * @param aConnectionTable is the table that contains all the objects connection.
 */
void Translator::generateCode(Table<Connection>& aConnectionTable){
  Modul* inMod;   // The module that takes an input.
  Modul* outMod;  // The module that gives an output.
  
  // SOME CHECK on the directive ctin-m for each entry of the theTableConnection.
  for(Table<Connection>::iterator con=theConnectionTable.begin(); con != theConnectionTable.end(); con++){
    inMod = theModulTable.find(con->getInModule());             // The input module on ctin-m.
    outMod = theModulTable.find(con->getOutModule());           // The output module on ctin-m.

    // We have limited the creation of macros;
    // i.e. the generation of Yting[50]=YS51_mod(.) is rejected at compiling time because YS51_mod is not defined if the limit is 50!
    // In this case the affectation of the inputs is realized by the user.
    ENFORCENOT(inMod->getInput() > NB_MAX_MACRO && !inMod->isManageCtin())
      ("ctin-m directive: ctin is prohibited for module (")(con->getInModule())(") because it has more than ")(NB_MAX_MACRO)(" inputs \n");
    // Check for the option specified on the directive ctin-m.
    con->checkOptions(inMod, outMod, theSpaceTable, theOperatorTable, theTrajectoryTable);
  } // End for Connections checks.

  // Generation of the Table composed by one simple connection for each element. We elaborate the actual theConnectionTable, we put all the simple 
  // connection in the allConnectionTable and then we copy all the simple connections in the theConnectionTable.
  // So allConnectionTable is a support Table used to translate the ancien theConnectionTable that group a lot of connection in the same vector element 
  // (i.e.: ctin A 1 from B 1 i-1 t#~1 is rapresented in one Table element). In allConnectionTable each Table element is one simple connection 
  // (the same example is splitted in three connections: ctin A 1 from B 1 i-1 t-1, ctin A 1 from B 1 i-1 t, ctin A 1 from B 1 i-1 t+1.
  Table<Connection> allConnectionTable; 
  bool boolijk;       // For ctinm: is a flag that avoid the regeneration in the point i j k for one t.
  int ctinCounter;
  for(Table<Connection>::iterator con=theConnectionTable.begin(); con != theConnectionTable.end(); con++){
    Connection newCon;  // A simple connection.
    ctinCounter=0;
    newCon.setInModule(con->getInModule());
    newCon.setOutModule(con->getOutModule());
    newCon.setRelt(con->getRelt());
    if(!con->isCtinType()){ // CASE directive CTINM......................................
      // For all steps time in the directive we generate the coordinates (relative:=1, or absolute:=-1 (if the coordinate doesn't exist:=0).
      for(int wt=0; wt<con->getTElements(); ++wt){  
        newCon.setT(con->ct[wt]);
        // Loop on the output; we have to remember do not variate togheter the output and the coordinates!!!! 
        for(int wnout=0; wnout<con->getOutElements(); ++wnout){ 
          boolijk=false;
          // We work firstly with the variation of i.
          //if(con->isI()){ // Inevitably, but for harmonisation.
          if(theModulTable.find(con->getOutModule())->getNbAxes()>0){ // Inevitably, but for harmonisation.
            newCon.setReli(con->getReli());
            for(int wi=0; wi<con->getIElements(); ++wi){
              if(con->ci[wi]!=0 || (con->ci[wi]==0 && !boolijk)){ // Inevitably, but for harmonisation.
                newCon.setI(con->ci[wi]);
                if(outMod->getNbAxes() >1){newCon.setJ(0); newCon.setRelj(true);} // For definition of this kind of connection.
                if(outMod->getNbAxes() >2){newCon.setK(0); newCon.setRelk(true);} // For definition of this kind of connection.

                newCon.setIn(con->getIn() + ctinCounter);
                if(con->getOutElements()>1)
                  newCon.setOut(con->getOut() + ctinCounter);
                else // con->getOutElements()==1.
                  newCon.setOut(con->getOut());  

                // We stock the simple connection in the temporary Table allConnectionTable.
                stockCheckConnection(allConnectionTable, newCon);
                ++ctinCounter;  // The simple connection counter (just for test).
                ENFORCENOT(ctinCounter>con->getInElements()) // Problem if the input number of connections is smaller than the connections created.
                  ("directive ctin: the number of input connections (")(con->getInElements())(") mismatch the number of axes connections (")
                  (ctinCounter)(") required between modules ")(con->getName())("\n");
                if(con->ci[wi]== 0) boolijk=true;
              }
            }
          } 
          if(theModulTable.find(con->getOutModule())->getNbAxes()>1){
            //if(con->isJ()){
            newCon.setRelj(con->getRelj());
            for(int wi=0; wi<con->getJElements(); ++wi){
              if(con->cj[wi]!=0 || (con->cj[wi]==0 && !boolijk)){ 
                newCon.setI(0); newCon.setReli(true); // For definition of this kind of connection.
                newCon.setJ(con->cj[wi]);
                if(outMod->getNbAxes() >2) 
                {newCon.setK(0); newCon.setRelk(true);}  // For definition of this kind of connection.
                newCon.setIn(con->getIn() + ctinCounter);
                if(con->getOutElements()>1)
                  newCon.setOut(con->getOut() + ctinCounter);
                else // con->getOutElements()==1.
                  newCon.setOut(con->getOut());  

                // We stock the simple connection in the temporary Table allConnectionTable.
                stockCheckConnection(allConnectionTable, newCon);
                ++ctinCounter;  // The simple connection counter (just for test).
                ENFORCENOT(ctinCounter>con->getInElements()) // Problem if the input number of connections is smaller than the connections created.
                  ("directive ctin: the number of input connections (")(con->getInElements())(") mismatch the number of axes connections (")
                  (ctinCounter)(") required between modules ")(con->getName())("\n");
                if(con->cj[wi]== 0) boolijk=true;
              }
            } 
          }
          if(theModulTable.find(con->getOutModule())->getNbAxes()>2){
          //if(con->isK()){
            newCon.setRelk(con->getRelk());
            for(int wi=0; wi<con->getKElements(); ++wi){
              if(con->ck[wi]!=0 || (con->ck[wi]==0 && !boolijk)){ 
                newCon.setI(0); newCon.setReli(true); // For definition of this kind of connection.
                newCon.setJ(0); newCon.setRelj(true); // For definition of this kind of connection.
                newCon.setK(con->ck[wi]);

                newCon.setIn(con->getIn() + ctinCounter);
                if(con->getOutElements()>1)
                  newCon.setOut(con->getOut() + ctinCounter);
                else // con->getOutElements()==1.
                  newCon.setOut(con->getOut()); 

                // We stock the simple connection in the temporary Table allConnectionTable.
                stockCheckConnection(allConnectionTable, newCon);
                ++ctinCounter;  // the simple connection counter (just for test).
                ENFORCENOT(ctinCounter>con->getInElements()) // Problem if the input number of connections is smaller than the connections created.
                  ("directive ctin: the number of input connections (")(con->getInElements())(") mismatch the number of axes connections (")
                  (ctinCounter)(") required between modules ")(con->getName())("\n");
                if(con->ck[wi]== 0) boolijk=true; // Not more useful but harmonisation.
              }
            } 
          }     
        }
      } // End for all t.
    }else{  // CASE directive CTIN...............................................       
      // For all the time instants we generate the coordinate (relative=1, absolute=-1, not used=0).
      for(int wt=0; wt<con->getTElements(); ++wt){  // So for each t fixed.
        newCon.setT(con->ct[wt]);
        // We work feeding the range of each axe.
        if(con->isI()){  // Inevitably, but for harmonisation.
          newCon.setReli(con->getReli());
        }
        if(con->isJ())
          newCon.setRelj(con->getRelj());
        if(con->isK())   
          newCon.setRelk(con->getRelk());
        // We loop for the creation of the connections (a cartesian loop).
        newCon.setJ(0); newCon.setK(0);                          
        for(int wnout=0; wnout<con->getOutElements(); ++wnout){ // Loop on all the output; we will remember that we can't accept to vary.
          // Togheter output and coordinate!!!! 
          for(int wi=0; wi<con->getIElements();  ++wi){
            newCon.setIn(con->getIn() + ctinCounter);
            if(con->getOutElements()>1)
              newCon.setOut(con->getOut() + ctinCounter);
            else // nbeout=1.
              newCon.setOut(con->getOut()); //= supout.
            newCon.setI(con->ci[wi]);
            if(con->isJ()){
              for(int wj=0; wj<con->getJElements(); ++wj){
                newCon.setIn(con->getIn() + ctinCounter);
                if(con->getOutElements()>1)
                  newCon.setOut(con->getOut() + ctinCounter);
                else // nbeout=1.
                  newCon.setOut(con->getOut()); //= supout.
                newCon.setJ(con->cj[wj]);

                if(con->isK()){
                  for(int wk=0; wk<con->getKElements(); ++wk){
                    newCon.setIn(con->getIn() + ctinCounter);
                    if(con->getOutElements()>1)
                      newCon.setOut(con->getOut() + ctinCounter);
                    else // nbeout=1.
                      newCon.setOut(con->getOut()); //= supout.
                    newCon.setK(con->ck[wk]);
                    stockCheckConnection(allConnectionTable, newCon);
                    ++ctinCounter;
                    ENFORCENOT(ctinCounter>con->getInElements()) // Problem if the input number of connections is smaller than the connections created.
                      ("directive ctin: the number of input connections (")(con->getInElements())(") mismatch the number of axes connections (")
                      (ctinCounter)(") required between modules ")(con->getName())("\n");
                  }
                }else{
                  stockCheckConnection(allConnectionTable, newCon);
                  ++ctinCounter;
                  ENFORCENOT(ctinCounter>con->getInElements()) // Problem if the input number of connections is smaller than the connections created.
                    ("directive ctin: the number of input connections (")(con->getInElements())(") mismatch the number of axes connections (")
                    (ctinCounter)(") required between modules ")(con->getName())("\n");
                }
              } // End for j.
            }else{
              stockCheckConnection(allConnectionTable, newCon);
              ++ctinCounter;
              ENFORCENOT(ctinCounter>con->getInElements()) // Problem if the input number of connections is smaller than the connections created.
                ("directive ctin: the number of input connections (")(con->getInElements())(") mismatch the number of axes connections (")
                (ctinCounter)(") required between modules ")(con->getName())("\n");
            } // End for i.
          }
        } // End for on output.    
      }
    } // End else.

    // We test that the number of connections created match the range of input. 
    ENFORCENOT(ctinCounter != con->getInElements())("directive ctin: the number of connection created(")
      (ctinCounter)(") do not match the input required(")(con->getInElements())(") in ")(con->getName())("\n");
  } // End global for.

  /* Charles comment:
     Faut-il verifier que les coordonnees ne sont pas aberrantes par rapport a l'espace. Je ne ferait pas ca a priori ici; 
     mais je pense que cela relevera des CDTL a gerer +ou- au moment de l'alimentation des inputs: si la connection
     qui doit alimenter une input provient d'un point hors de l'espace temps, alors ... PLM je mettrais ZERO ! */

  // Just for test.
  // theDisplay.display(theConnectionTable); cout << "---------------------------" << endl; theDisplay.display(allConnectionTable);

  // We put all the connections in the right vector: theConnectionTable (at the moment they are in allConnectionTable).
  theConnectionTable.clear();
  for(Table<Connection>::iterator con=allConnectionTable.begin(); con != allConnectionTable.end(); con++)
    theConnectionTable.push_back(*con);
}

/**
 * Stock the new connection in the Table allConnectionTable if there are no anomalies.
 * @param allConnectionTable is the table containing all the connections.
 * @param newCon is the connection we want to add.
 */
void Translator::stockCheckConnection(Table<Connection> & allConnectionTable, Connection newCon){
  // A module in the point i,j,k,t can't be connected with himself (we can connect with his alter-ego only from other points of the space).
  if(newCon.getInModule() == newCon.getOutModule())
    // We can do this test only when the coordinates are express in a relative way.
    if(newCon.getReli() != -1 && newCon.getRelj() != -1 && newCon.getRelk() != -1 && newCon.getRelt() > 0)
      ENFORCENOT(newCon.getI()==0 && newCon.getJ()==0 && newCon.getK()==0 && newCon.getT()==0)
        ("ctin directive: modul ")(newCon.getOutModule())(" connected to himself not allowed\n");

  // Charles comment: multi, on considere que les coordonnees se rapportent a celle de l'OUT.
  Modul* outMod = theModulTable.find(newCon.getOutModule()); // The output module on ctin.

  // An absolute coordinate must be inside the space.
  ENFORCENOT((newCon.getReli()==-1 && newCon.getI()>outMod->getYA(1)) ||    
      (newCon.getRelj()==-1 && newCon.getJ()>outMod->getYA(2)) ||    
      (newCon.getRelk()==-1 && newCon.getK()>outMod->getYA(3))  )
    ("ctin directive: module ")(outMod->getName())(" has at least one absolute coordinate out of the defined space\n");

  for(Table<Connection>::iterator con=allConnectionTable.begin(); con != allConnectionTable.end(); con++){
    // One input at least one connection.
    ENFORCENOT(con->getInModule() == newCon.getInModule() && con->getIn() == newCon.getIn())
      ("ctin directive: input ")(newCon.getInModule())(" ")(newCon.getIn())(" is already feed (only one connection for each input is allowed) \n");

    // The connections that are repeted are not considered an anomaly; this is the case of relative coordinate.
    if(     con->getOutModule() == newCon.getOutModule() 
        &&    con->getOut()     == newCon.getOut()
        &&  con->getInModule()  == newCon.getInModule()
        &&    con->getIn()      == newCon.getIn()
        &&    con->getI()       == newCon.getI()
        &&    con->getJ()       == newCon.getJ()
        &&    con->getK()       == newCon.getK()
        &&    con->getT()       == newCon.getT()){
      cout << "ctin warning: duplicated connection: " << newCon.getOutModule() << " " << newCon.getOut() << " ====> " << newCon.getInModule();
      cout << " " << newCon.getIn() << endl;
      // We should understand how we have to do for the absolute coordinate !? 
    }
  }

  // Too much connections to generate: we limit the max size of the connections table.
  ENFORCENOT(allConnectionTable.size() >= NB_MAX_CONNECT)
    ("ctin directive: too much connections required (max is ")(NB_MAX_CONNECT)(") \n");

  // All the controls are ok, we stock.
  allConnectionTable.push_back(newCon);
}

/**
 * Generation of the code relative to the directive order.
 * This method is directly linked to the class Order. For all the Order objects in the table anOrderTable we generate some code.
 * @param anImplementation is the generated file we are writing on.
 * @param anOrderTable the table that contains all the Order.
 */
// blockorder() for Yao8.c. The structure of this function has changed a lot in the new version 9 of Yao. 
// Some function called inside have been suppressed because too small in order to make less confusion.
void Translator::generateCode(ostream& anImplementation, Table<Order>& anOrderTable){

  // Check the max number of order tokens.
  ENFORCE(anOrderTable.size() < NB_MAX_ORDER_TOKENS)
    ("too much order tokens found (max is ")(NB_MAX_ORDER_TOKENS)(") \n may be, should you split your order directive ?\n");

  /*  For see/debug
   *  int j=0;
      for(Table<Order>::iterator ord=anOrderTable.begin(); ord < anOrderTable.end(); ord++){
      cout << endl << "Vector " << j++ << endl;
      for(vector<string>::iterator ordAPP=ord->orderTokens.begin(); ordAPP < ord->orderTokens.end(); ordAPP++)
      cout << *ordAPP << " ";  
      cout << endl;}*/
  for(Table<Order>::iterator ord=anOrderTable.begin(); ord < anOrderTable.end(); ord++)
    if(ord->getOrderPhase()==1){ // Case directive modinspace.

      // Firstly we generate code for the forward.
      orderGenerator(anImplementation, string("forward"), *ord);

      // Linear tangent case.
      if(theContext.isGradTestOrIncremental()){
        orderGenerator(anImplementation, string("linward"), *ord);
      }

      // Test derivation function case.
      if(theContext.isGradTest()){ 
        orderGenerator(anImplementation, string("dfward"), *ord); // dfward function on the space.
        dfwardGridGenerator(anImplementation, *ord);              // dfward function on one grid point.
      }

      // Then backward, but before we reverse the order of the axes and of the tokens. 
      ord->backOrder();

      // For see/debug: test the reversed vector.
      /*cout << "The orderTokens after the backOrder(): " << endl;
        for(vector<string>::iterator token=ord->orderTokens.begin(); token < ord->orderTokens.end(); token++)
        cout << " " << *token;
        cout << endl;*/

      orderGenerator(anImplementation, string("backward"), *ord); 
    }else{ // Case directive spaceintraj.



      // The code here is the same that phase==1 but we use orderGeneratorMulti instead of orderGenerator.
      // We have to maintain both simultaneously.
      orderGeneratorMulti(anImplementation, string("forward"), *ord); // Firstly we generate code for the forward.
      if(theContext.isGradTestOrIncremental())  // Linear tangent case.
        orderGeneratorMulti(anImplementation, string("linward"), *ord); 
      // Charles comment: l'aspect multi est-il opportun pour les test des derivees !? may be not (ARAR).
      if(theContext.isGradTest()){                                      // Test derivation function case.
        orderGeneratorMulti(anImplementation, string("dfward"), *ord);  // dfward function on the space.
        dfwardGridGenerator(anImplementation, *ord);                    // dfward function on one grid point. 
      }

      // Then backward, but before we reverse the order of the axes and of the tokens. 
      ord->backOrder ();  
      orderGeneratorMulti(anImplementation, string("backward"), *ord); 

      // Note: we can reverse all the time that we want the token vector, we just have to backOrder().
    } // End if-else and end for.
  
  // Ending the directive Order, we perform the last phase.

  // Charles comment: on va produire automatiquement la phase 3 dans l'ordre de declaration des trajectoires !
  // pour continuer a avoir des fonctions *ward_order qui semble avoir encore leur utilite. 

  Order ord(&theModulTable); 
  ord.setOrderPhase(3); // To signal that we are in the last phase where there are all trajectories togheter.
  for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++)
    if(tra->isCounterOrder()) // Only the trajectories that has been part of a phase spaceintraj.
      ord.orderTokens.push_back(tra->getName());

  // The code here is the same that phase==1 but we use orderGeneratorMulti instead of orderGenerator.
  // We have to maintain both simultaneously.
  orderGeneratorMulti(anImplementation, string("forward"), ord);    // Firstly we generate code for the forward.
  if(theContext.isGradTestOrIncremental())
    orderGeneratorMulti(anImplementation, string("linward"), ord);  // Linear tangent case.
  // Charles comment: l'aspect multi est-il opportun pour les test des derivees !? may be not (ARAR).
  if(theContext.isGradTest()){                                      // Test derivation function case.
    orderGeneratorMulti(anImplementation, string("dfward"), ord);   // dfward function on the space.
    dfwardGridGenerator(anImplementation, ord);                     // dfward function on one grid point.
  }

  // Then backward, but before we reverse the order of the axes and of the tokens. 
  ord.backOrder ();  
  orderGeneratorMulti(anImplementation, string("backward"), ord); 

  // We produce the *ward of the operators. At the moment we generate only forward_operator, backward_operator and linward_operator.
  wardOperatorGenerator(anImplementation);
  //float b = parallelLoops;
  //float a = ((float)parallelLoops) / totalLoops * 100;

  // In order to have a  statistic of the parallelization procedure we print some usefulle information here.
  if(theContext.isParallel()){
    cout << endl << "Parallelization profiling:" << endl;
    cout << "  The number of threads used for the parallelism is: ";
    if(theContext.getThreadsNumber()) 
      cout << theContext.getThreadsNumber() << ".";
    else cout << "default.";
    cout << endl << "  The number of total loops is " << totalLoops  << " containing " << totalModulesInOrders << " total modules.";
    //cout << endl << "  In the forward procedure:" << endl
    cout << endl << "  The number of parallelized loop is " << parallelForwardLoops << " containing " << parallelForwardModules << " modules," << endl
      //<< "  the number of total loop is " << totalLoops  << " containing " << theModulTable.size() << " total modules," << endl
      << "  the percentage of parallel loops is " << ((float)parallelForwardLoops) / totalLoops * 100 << "%" << endl
      //<< "  and the percentage of modules that have been parallelized is " << ((float)parallelModules) / theModulTable.size() * 100 << "%." << endl;
      << "  and the percentage of modules that have been parallelized is " << ((float)parallelForwardModules) / totalModulesInOrders * 100 << "%." << endl;

    //cout << endl << "theModulTable.size() " << theModulTable.size() << endl;
    //cout << endl << "totalModulesInOrders " << totalModulesInOrders << endl;

    if(theModulTable.size() - totalModulesInOrders) // If there modules that are not used for computation we show it.
      cout << "  There are " << theModulTable.size() - totalModulesInOrders << " modules not present in an order directive." << endl;
    //cout << "  In the backward procedure:" << endl
    if(parallelForwardLoops){
      cout << "  In the backward procedure:" << endl
        //<< "    the number of parallelized loop is " << parallelBackwardLoops << " containing " << parallelBackwardModules << " modules," << endl
        << "    The number of atomic update in the parallel regions is " << totalAtomicOperations
        << ", the total number of update is " << theConnectionTable.size() << "." << endl
        << "    The percentage of atomic update is " << ((float)totalAtomicOperations) / theConnectionTable.size() * 100 << "%" << endl;
    }
    cout << endl;
  }
}

/**
 * Manages the code generation of the functions *ward. 
 * This generation is relative only to the modinspace option of the order directive.
 * The ward to be generated in the file Y2projectName.h are: forward, linward, dfward (if GRADTEST option setted) and backward.
 * This method is called from the method generateCode.
 * @param anImplementation is the generated file we are writing on.
 * @param wardKind the kind of *ward to be generated.
 * @param ord is the object Order that we are working at the moment of the method call.
 */
// genorder() for Yao8.c. In this new version there is the parallelization.
void Translator::orderGenerator(ostream& anImplementation, string wardKind, Order ord){
  int firstAxis=0;                          // Which axis is the first axis of the order? 
                                            // firstAxis Is used in the parallel generation (for the atomic operations) of the backward: 1=i, 2=j, 3=k.
  bool wasAxe=false;                        // In order to understand if the previous token was an axe.
  bool wasOrder=false;                      // In order to understand if the previous token was an order.
  bool parallel=false;                      // True if the current nested loop may be parallelized (so if the condition ct=0 && cY!=0
                                            // is not present, with cY the index of the extern loop).
  bool axeTable[3] = {false, false, false}; // A three dimension table that contains true in the relative axe position if the axe token is already met.
  int dimAxe=0;                             // The actual dimension of the axeTable: the number of true elements.
  Modul * mod;                              // A module encountered in the tokens sequence.
  char a, b;                                // They contain the letter 'i', 'j', 'k' in function of the actual axes in the sequence.
  ostringstream streamInputWardFunctions;   // It's useful in order to generate the string inputWardFunctions.
  string inputWardFunctions;                // Parameters in input for functions *ward (Yting[i] sequence in Y2_project_file).
  int w1;                                   // Just a counter. 
  string fctWard;                           // Name of the function to call.
  string forward("forward"), linward("linward"), dfward("dfward"), backward("backward"), flinward("flinward"); // Like this is more confortable.
  string debugMessage;                      // For the debugging.

//  if(wardKind==forward)
//    anImplementation << "cout <<  \"The number of threads used is: omp_get_num_threads();\" << endl;" << endl;
  
  if(wardKind == dfward){                   // Case dfward: there are some parameters in input to the genereted function.
    anImplementation << "\nint Ydfward_space_" << ord.getName();
    anImplementation << "(int modop, char *nmmod, int All, int KeKo, int koleft, float pdx, float ptol, int yi, int yj, int yk)\n{\n\t int nbko=0;\n";
  }else anImplementation << "\n int Y" << wardKind << "_space_" << ord.getName() << "()\n{\n"; // Normal case.

  Space * spaceOrOperator = theSpaceTable.find(ord.getName());
  if(!spaceOrOperator)   
    spaceOrOperator = theOperatorTable.find(ord.getName());

  anImplementation << "\t YA1=" << spaceOrOperator->getYA(1) << "; YA2=" << spaceOrOperator->getYA(2) << "; YA3=" << spaceOrOperator->getYA(3) << ";\n";

  // Init of the grid index loop variables.
  anImplementation << "Yi=-1; Yj=-1; Yk=-1; /* init des indices de maille: maj par la boucle si valide*/\n";  

  // In the case of debug.
  if( (wardKind==forward  && theContext.isDebugForward())  || 
      (wardKind==backward && theContext.isDebugBackward())  || 
      (wardKind==linward  && theContext.isDebugLinward()))
    anImplementation << "printf (\"dbg: in function: Y" << wardKind << "_space_" << ord.getName() << "\\n\");\n";

/*
  if(wardKind==forward)
    cout << endl << "We are in a forward----" << endl;
  else cout << endl << "We are in a backward----" << endl;

  for(vector<string>::iterator token=ord.orderTokens.begin(); token < ord.orderTokens.end(); token++){
    cout << *token << " ";

  }
  cout << endl;
*/

  // For the generation of a parallel forward code we control:
  // wardKind==forward we are generating the forward code;
  // parallel the option parallel is enabled;
  // dimAxe==0 && wasOrder we are in the first axis, the one that we want parallelize.
  for(vector<string>::iterator token=ord.orderTokens.begin(); token < ord.orderTokens.end(); token++){
    if(*token == "YA1"){
      if((wardKind==forward || wardKind==backward) && parallel && dimAxe==0 && wasOrder){
        firstAxis=1; // The first axis of the order is i;
        anImplementation << "#pragma omp parallel for ";
        if(theContext.getThreadsNumber()) anImplementation << "num_threads(" << theContext.getThreadsNumber() << ")" << endl;
        else  anImplementation << endl;
        anImplementation << "for(YY=0; YY<YA1_" << ord.getName() << "; ++YY){" << endl
          << "  Yi=YY;" << endl;
      }else anImplementation << "for(Yi=0; Yi<YA1_" << ord.getName() << "; ++Yi)\n";    
      wasAxe=true; flagAxe(axeTable, 0, dimAxe); wasOrder=false;
    }
    else if(*token == "YA2"){
      if((wardKind==forward || wardKind==backward) && parallel && dimAxe==0 && wasOrder){
        firstAxis=2; // The first axis of the order is j;
        anImplementation << "#pragma omp parallel for "; 
        if(theContext.getThreadsNumber()) anImplementation << "num_threads(" << theContext.getThreadsNumber() << ")" << endl;
        else  anImplementation << endl;
        anImplementation << "for(YY=0; YY<YA2_" << ord.getName() << "; ++YY){" << endl
                         << "  Yj=YY;" << endl;
      }else anImplementation << "for(Yj=0; Yj<YA2_" << ord.getName() << "; ++Yj)\n";
      wasAxe=true; flagAxe(axeTable, 1, dimAxe); wasOrder=false; 
    }
    else if(*token == "YA3"){
     if((wardKind==forward || wardKind==backward) && parallel && dimAxe==0 && wasOrder){
        firstAxis=3; // The first axis of the order is k;
        anImplementation << "#pragma omp parallel for "; 
        if(theContext.getThreadsNumber()) anImplementation << "num_threads(" << theContext.getThreadsNumber() << ")" << endl;
        else  anImplementation << endl;
        anImplementation << "for(YY=0; YY<YA3_" << ord.getName() << "; ++YY){" << endl
                         << "  Yk=YY;" << endl;
      }else anImplementation << "for(Yk=0; Yk<YA3_" << ord.getName() << "; ++Yk)\n";    
     wasAxe=true; flagAxe(axeTable, 2, dimAxe); wasOrder=false;
    }
    else if(*token == "YB1"){
      if((wardKind==forward || wardKind==backward)  && parallel && dimAxe==0 && wasOrder){
        firstAxis=1; // The first axis of the order is i;
        anImplementation << "#pragma omp parallel for "; 
        if(theContext.getThreadsNumber()) anImplementation << "num_threads(" << theContext.getThreadsNumber() << ")" << endl;
        else  anImplementation << endl;
        anImplementation << "for(YY=YA1_" << ord.getName() << "-1; YY>=0; --YY){" << endl
                         << "  Yi=YY;" << endl;
      }else anImplementation << "for(Yi=YA1_" << ord.getName() << "-1; Yi>=0; --Yi)\n"; 
      wasAxe=true; flagAxe(axeTable, 0, dimAxe); wasOrder=false;
    }
    else if(*token == "YB2"){
      if((wardKind==forward || wardKind==backward) && parallel && dimAxe==0 && wasOrder){
        firstAxis=2; // The first axis of the order is j;
        anImplementation << "#pragma omp parallel for ";
        if(theContext.getThreadsNumber()) anImplementation << "num_threads(" << theContext.getThreadsNumber() << ")" << endl;
        else  anImplementation << endl;
        anImplementation << "for(YY=YA2_" << ord.getName() << "-1; YY>=0; --YY){" << endl
                         << "  Yj=YY;" << endl;
      }else anImplementation << "for(Yj=YA2_" << ord.getName() << "-1; Yj>=0; --Yj)\n"; 
    wasAxe=true; flagAxe(axeTable, 1, dimAxe); wasOrder=false;}
    else if(*token == "YB3"){
      if((wardKind==forward || wardKind==backward) && parallel && dimAxe==0 && wasOrder){
        firstAxis=3; // The first axis of the order is k;
        anImplementation << "#pragma omp parallel for "; 
        if(theContext.getThreadsNumber()) anImplementation << "num_threads(" << theContext.getThreadsNumber() << ")" << endl;
        else  anImplementation << endl;
        anImplementation << "for(YY=YA3_" << ord.getName() << "-1; YY>=0; --YY){" << endl
                         << "  Yk=YY;" << endl;
      }else anImplementation << "for(Yk=YA3_" << ord.getName() << "-1; Yk>=0; --Yk)\n"; 
      wasAxe=true; flagAxe(axeTable, 2, dimAxe); wasOrder=false;
    }
    else{
      if(wasAxe==1){ // If before we had an axe and now is not an axe ==> open parenthesis. 
        anImplementation << "{\n";
        wasAxe = 0;
      }
      if(*token == "order" || *token == "ORDER"){
        wasOrder = true;
        if(dimAxe == 0 && (wardKind==forward || wardKind==backward) && theContext.isParallel()){
            parallel = parallelVerification(token, ord, wardKind);
          /*if(wardKind==forward)
            parallel = parallelVerification(token, ord);
          else if(wardKind==backward && theSpaceTable.find(ord.getName())->getYA(firstAxis)>1)
          {
            parallel = true;
          }
          else parallel=false;
            cout << endl << "Valore del first Axis..." << firstAxis;
            cout << endl << "Valore dell'asse..." << theSpaceTable.find(ord.getName())->getYA(firstAxis);
            cout << endl << "Valore di parallel..." << parallel << endl;

          //------------>cout << endl << "The value of the axeTable after is parallel:"<< axeTable[0]<<" "<<axeTable[1]<<" "<<axeTable[2]<<endl; // For see/debug. 
          //-------->//if(parallel) cout << "PARALLELIZZABILE   " << endl;
          //-------->//else cout << "NON parallelizzabile " << endl; 
        */
          
          }

        continue;
      }
      if(*token == "forder" || *token == "FORDER"){               
        anImplementation << "\n}" << endl;
        //cout << endl<<"The value of the axeTable BEFORE the unflag:"<< axeTable[0]<<" "<<axeTable[1]<<" "<<axeTable[2]<<endl; // For see/debug. 
        unflagAxe(axeTable, ord, token, dimAxe); 
        wasOrder=false;
        if((wardKind==forward || wardKind==backward) && parallel && dimAxe==0){ 
          anImplementation << "}" << endl;
        }
        //cout <<endl<<"The value of the axeTable AFTER the unflag: "<<axeTable[0]<<" "<<axeTable[1]<<" "<<axeTable[2]<<endl; // For see/debug.
      }else{ // Here the token is a module. This module should not be noward.

        wasOrder=false;
        
        // Init for the actual module 
        mod = theModulTable.find(*token);

        // Test: the module should not be noward.
        ENFORCE(!mod->isNoward())("order modinspace: ")(mod->getName())(": noward module are not allowed here\n");
        // Test: the module should belong to the space.
        ENFORCE(mod->getSpaceOrOperator() == ord.getName())("order modinspace: module ")(mod->getName())
          (" does not belong to ")(ord.getName())(" space\n");

        //CONTROLLARE QUESTO CASO-----------------------------------------------------------------
        // Case of dfward_order ---> 
        if(wardKind==dfward){
          // Test: if ok we generate the call code to dfward for this module.
          if(!mod->isNoward() && mod->getOutput()>0){
            // Research of the axes.
            searchAxes(axeTable, &a, &b);

            // Generation of the dfward code for the current module.
            dfwardGeneratorOrderModule(anImplementation, ord, *mod, dimAxe, a, b);
          }
          continue;
        }
        // End of case dfward.
        // ----------------------------------------------------------------------------------------------

        // Creation of the input parameters for the *ward function if necessary (so if not autonet or array, in this case is not useful).
        streamInputWardFunctions.str("");
        inputWardFunctions = "";
        if(!mod->isAutonet() && !mod->isArray()){  
          for(w1=0; w1<mod->getInput(); ++w1) streamInputWardFunctions <<" Yting[" << w1 << "],";
          inputWardFunctions = streamInputWardFunctions.str();
          if(inputWardFunctions.size()) 
            inputWardFunctions.replace(inputWardFunctions.size()-1, 1, " ");
        }

        // Increment of the counter in the Order directive: warning if it has already appear (only with forward, so the first time).
        if(wardKind==forward){ 
          if(mod->isCounterOrder()){
            cout << "WARNING: the module " << mod->getName() << " appears more than once in order directive\n";
            cout << "         you should rather use clone key word !?\n";
          }
          mod->setCounterOrder(true);
        }

        // Automatic feed of the input table Yting (this is for the forward, backward and linward).
        if(!mod->isManageCtin())
          feedward(anImplementation, ord, mod->getName(), 'I', firstAxis,false);

        // Feed of Beta (Ytbeta) for the Linear Tangent.
        if(wardKind==linward)
          feedward(anImplementation, ord, mod->getName(), 'B', firstAxis,false);

        // Name of the function to call.
        fctWard=wardKind;
        if(fctWard==linward){  
          if(!mod->isNetward() && !mod->isAutonet())
            fctWard=backward;
          else
            fctWard=flinward;
        }

        // We have to reinitialize the Jacobian matrix before the call of backward and linward? 
        // If there is some input.
        if(fctWard==backward && mod->getInput()>0){       
          // This should not be necessary for the NN and for hidjac.
          if(!mod->isNetward() && !mod->isAutonet() && !mod->isHidjac()){      
            anImplementation << "\t memset(Yjac, 0, " << maxNbJacobianInput*mod->getOutput() << "*sizeof(" << theContext.getReal() << "));\n";
          }
        }

        // We write the call to the function *ward().

        // Generation of the call to the function *ward(inputWardFunctions) according to the dimension.
        // Charles comment: ici, (et PLM) on ne test pas, en particulier pour l'appel a la fonction backward (cas
        // de l'Adjoint et du LT), le nombre d'input because of the ghost module concept.
        if(dimAxe==1){  
          a=b=' '; //Y a=b=0; 
          searchAxes(axeTable, &a, &b);
          anImplementation << "\t Y" << *token << "(Y" << a << ")->" << fctWard<< "(" << inputWardFunctions << ");\n";
        }else if(dimAxe==2){  
          a=b=' '; //Y a=b=0;  
          searchAxes(axeTable, &a, &b);
          anImplementation << "\t Y" << *token << "(Y" << a << ", Y" << b << ")->" << fctWard << "(" << inputWardFunctions << ");\n";
        }else if(dimAxe==3)
          anImplementation << "\t Y" << *token << "(Yi, Yj, Yk)->" << fctWard << "(" << inputWardFunctions << ");\n";
        else ENFORCE(false)("order modinspace failed: sorry, unpredictable error; dimaxe=")(dimAxe)(" \n");

        // Automatic backward and linear tangent: the module must have inputs: 
        if(mod->getInput()>0){       
          if(wardKind==backward){       
            // Generation of the computation of the betas (except for the modules NN and hidjac).
            if(!mod->isNetward() && !mod->isAutonet() && !mod->isHidjac()){
              anImplementation << "\t Yvsmatt (YNBS_" << mod->getName() << ", YNBI_" << mod->getName();
              anImplementation << ", YMAX_JAC_NBI, &YG1Y_" << mod->getName() << ", Yjac[0], Ytbeta);\n";
            }
            // Then retropropagation of betas toward the Alpha (YG: gradient) of the modules predecessor.
            if(!mod->isManageCtin())
              feedward(anImplementation, ord, mod->getName(), 'A', firstAxis, parallel);

            // CONTROLLARE NEL CASO gradtest() che cosa cambia al livello della parallelizazione---------------------------------------------
            // For the test of the adjoint on the module.
            if(theContext.isGradTest()){
              anImplementation << "\t if (Ytestad_module) {\n";
              feedward(anImplementation, ord, mod->getName(), 'D', firstAxis, false);
              anImplementation << "\t\t\tYLTRes = Yprosca(&YD1Y_" << mod->getName();
              anImplementation << ", &YG1Y_" << mod->getName() << ", YNBS_" << mod->getName() << ");\n";

              anImplementation << "\t\t\tYAdRes = Yprosca(Yting, Ytbeta, YNBI_" << mod->getName() <<");\n";
              anImplementation << "\t\t\tif (!Ytesterrad_mod(\"" << mod->getName() << "\", YLTRes,YAdRes)) return(0);\n\t }\n";
            }
          }else if(wardKind==linward){
            // Generation of the computation of the grad (except for the modules NN and hidjac).
            if(!mod->isNetward() && !mod->isAutonet() && !mod->isHidjac()){       
              anImplementation << "\t Yvsmat (YNBS_" << mod->getName() << ", YNBI_" << mod->getName();
              anImplementation << ", YMAX_JAC_NBI, &YG1Y_" << mod->getName() << ", Yjac[0], Ytbeta);\n";
            }
            // For the test of the adjoint on the module.
            if(theContext.isGradTest()){ 
              anImplementation << "\t if (Ytestad_module)\n\t {\tmemcpy(&YD1Y_" << mod->getName() << ", &YG1Y_" << mod->getName();
              anImplementation << ", YNBS_" << mod->getName() << "*sizeof(YREAL));\n\t }\n";
            }
          }
        }

        // In the case of debug.
        if     (wardKind==forward)  debugMessage="F: ";
        else if(wardKind==backward) debugMessage="B: ";
        else if(wardKind==linward)  debugMessage="L: ";
        if(mod->getInput()>0){   // If there are inputs.
          if(theContext.isDebugInput())
            anImplementation << "\t Ydbg_ting (\"" << debugMessage << "\", YNBI_" << *token << ", \"" << *token << "\");\n";
          if(theContext.isDebugBeta()) 
            anImplementation << "\t Ydbg_beta (\"" << debugMessage << "\", YNBI_" << *token << ", \"" << *token << "\");\n";
          if(theContext.isDebugNan())       
            anImplementation << "\t Ydbg_nanf (\"" << debugMessage << "\", YNBI_" << *token << ", \"" << *token << "\");\n";
        }

        continue;
      }
    }
  }
//Solo di prova per adesso per la parallelizazione.......
  //anImplementation << endl << "//}" << endl;
//  if(wardKind==forward){ 
//  anImplementation << endl << "}" << endl;
//  }
//.......................................................


  if(wardKind==dfward)
    anImplementation << "\n\t return(nbko);\n}\n";
  else anImplementation << "\n\t return(0);\n}\n";
}

/** 
 * The actual number of axes encountered in the scanning of the orderTokens vector is contained in a vector of three elements: 
 * the three axes YA1, YA2, YA3.
 * Every time we do an order for an axe this axe is flagged on the vector. If we do un forder all the axes till the precedent order are unflagged.
 * This way we can check the consistency of the user definition and to manage the generation of the code (because we know the actual dimension).
 * @param axeTable is the actual axe table to be modified.
 * @param axe is the axe to be added to the table.
 * @param dimAxe is the actual dimension of the axeTable: the number of true elements
 */
void Translator::flagAxe(bool axeTable[3], int axe, int & dimAxe){       
  // Check if the axe has already been met in the hierarchy.
  ENFORCE(!axeTable[axe])("fail: in order, axe ")(axe+1)(" previously appeared \n");
  axeTable[axe] = true;
  ++dimAxe;
}

/** 
 * The actual number of axes encountered in the scanning of the orderTokens vector is contained in a vector of three elements: 
 * the three axes YA1, YA2, YA3.
 * Every time we do an order for an axe this axe is flagged on the vector. If we do un forder all the axes till the precedent order are unflagged.
 * This method allows to unflag all the sequence of axes till the precedent order in the vector that contains all the tokens of the order orderTokens.
 * It is more or less the opposit of flagAxe().
 * @param axeTable is the actual axe table to be modified.
 * @param ord is the object Order that we are working at the moment of the method call.
 * @param tokenIndex is the actual token pointer where we arrived scanning the sequence.
 * @param dimAxe is the actual dimension of the axeTable: the number of true elements.
 */
void Translator::unflagAxe(bool axeTable[3], Order ord, vector<string>::iterator tokenIndex, int & dimAxe){
  int waxe;

  // For see/debug
  /*cout << endl << "tokens" << endl;
    for(vector<string>::iterator token=ord.orderTokens.begin(); token < ord.orderTokens.end(); token++) cout << " " << *token; cout << endl; */

  // We firstly find the first axe to be unflagged.
  while(1){
    waxe = -1;
    if(*tokenIndex == "YA1" || *tokenIndex == "YB1") waxe=0;
    else if(*tokenIndex == "YA2" || *tokenIndex == "YB2") waxe=1;
    else if(*tokenIndex == "YA3" || *tokenIndex == "YB3") waxe=2;
    if(waxe!=-1)
      if(axeTable[waxe]) // We have found the first axe.
        break;
    --tokenIndex;
    //if(tokenIndex < ord.orderTokens.begin()) 
    //  break; 
  }

  // Then we unflag till the precedent order
  while(*tokenIndex != "order" && *tokenIndex != "ORDER" /*&& tokenIndex>=ord.orderTokens.begin()*/){
    waxe = -1;
    if(*tokenIndex == "YA1" || *tokenIndex == "YB1") waxe=0; 
    else if(*tokenIndex == "YA2" || *tokenIndex == "YB2") waxe=1;
    else if(*tokenIndex == "YA3" || *tokenIndex == "YB3") waxe=2;
    if(waxe!=-1){               
      axeTable[waxe]=false;
      --dimAxe;
      //    printf("deflag: T[%d]=%d \n", waxe, axeTable[waxe]);     // For see/debug. 
    }
    --tokenIndex;
  }
}

/**
 * Determination of the actual axes (if the dimension is lesser than three otherwise is 'i', 'j', 'k' for sure).
 * At the end of the method the parameter a and b will contain the first and the second axe in function of the actual dimension.
 * @param axeTable is the actual axe table.
 * @param a is the pointer to the letter that represent the first axe. 
 * @param b is the pointer to the letter that represent the second axe.
 */
void Translator::searchAxes(bool axeTable[3], char *a, char *b){       
  *a=*b=' ';
  // printf("in search: %d %d %d \n", axeTable[0], axeTable[1], axeTable[2]); // For see/debug. 
  if(axeTable[0]==1){ 
    *a='i';
    if (axeTable[1]==1) 
      *b='j'; 
    else *b='k';
  }else if (axeTable[1]==1)
  {*a='j'; *b='k';}
  else *a='k';
}

/**
 * Code generation of the dfward in the directive order of a module. 
 * This generation allows to test the code of the backward functions by the call of Ytestdf_() function and the check of ko. 
 * @param anImplementation is the generated file we are writing on.
 * @param ord is the object Order that we are working at the moment of the method call.
 * @param mod is the module that we are interested for the dfward generation. 
 * @param dimAxe is the actual dimension of the axeTable: the number of true elements.
 * @param a is the the letter that represent the first axe. 
 * @param b is the the letter that represent the second axe.
 */
void Translator::dfwardGeneratorOrderModule(ostream& anImplementation, Order ord, Modul mod, int dimAxe, char a, char b){
  ostringstream streamInputWardFunctions; // It's useful in order to generate the string inputWardFunctions.
  string inputWardFunctions;              // Parameters in input for functions *ward (Yting[i] sequence in Y2_project_file).
  int w1;

  ENFORCENOT(dimAxe>3 || dimAxe<1)("fail: sorry, unpredictable error dimaxe=")(dimAxe)(" \n");

  // Yting feed for this module: we create all the code "Yting[]=Y..." in feedward.
  feedward(anImplementation, ord, mod.getName(), 'I', 0, false);

  // Test on the module or on "All".
  anImplementation << "\tif (!strcmp(nmmod, \"" << mod.getName() << "\") || All)\n\t{\n";

  // Remark1 and remark2 : cf dfwardGeneratorModule (gendfward_mod for Charles).

  // Creation of the input parameters for the *ward function if necessary (so if not autonet or array, in this case is not useful).
  streamInputWardFunctions.str("");
  inputWardFunctions = "";
  if(!mod.isAutonet() && !mod.isArray()){  
    for(w1=0; w1<mod.getInput(); ++w1) streamInputWardFunctions <<" Yting[" << w1 << "],";
    inputWardFunctions = streamInputWardFunctions.str();
    if(inputWardFunctions.size()) 
      inputWardFunctions.replace(inputWardFunctions.size()-1, 1, " ");
  }

  // Test on the coordinate point arrived to the end.
  anImplementation << "\t if (Yi>=yi && Yj>=yj && Yk>=yk) \n\t {";

  // Call of the testdf function according to the axe dimension; 
  // Charles comment: nb: pas de test pour les modules sans input, les RN, les hidjac mais il faut quand meme faire un forward apres.
  if(dimAxe==1){     
    if(mod.getInput()>0 && !mod.isNetward() &&  !mod.isAutonet() && !mod.isHidjac()){        
      if(mod.getTime() > 0){
        anImplementation << "\tnbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() << ",YNBS_";
        anImplementation << mod.getName() << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName() << "[Y" << a << "]->Ystate[0],Y";
        anImplementation << mod.getName() << "[Y" << a << "]);\n";
      }else{
        anImplementation << "\tnbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() << ",YNBS_";
        anImplementation << mod.getName() << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName() << "[Y" << a << "]->Ystate,Y";
        anImplementation << mod.getName() << "[Y" << a << "]);\n";
      }
    }
    anImplementation << "\t\t if (nbko>=koleft) return(nbko);\n\t }\n"; // Test max ko reach.
    anImplementation << "\t}\n"; // End of if module or All.
    anImplementation << "\t Y" << mod.getName() << "(Y" << a << ")->forward(" << inputWardFunctions << ");\n"; // In any case.
  }else if(dimAxe==2){     
    if(mod.getInput()>0 && !mod.isNetward() &&  !mod.isAutonet() && !mod.isHidjac()){        
      if(mod.getTime() > 0){
        anImplementation << "\tnbko += Ytestdf_" << mod.getName()  << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName();
        anImplementation << ",YNBS_" << mod.getName() << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName();
        anImplementation << "[Y" << a << "][Y" << b << "]->Ystate[0],Y" << mod.getName()  << "[Y" << a << "][Y" <<b << "]);\n";
      }else{
        anImplementation << "\tnbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName();
        anImplementation << ",YNBS_" << mod.getName() << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName() << "[Y" << a;
        anImplementation << "][Y" << b << "]->Ystate,Y" << mod.getName() << "[Y" << a << "][Y" << b << "]);\n";
      }
    }
    anImplementation << "\t\t if (nbko>=koleft) return(nbko);\n\t }\n"; // Test max ko reach 
    anImplementation << "\t}\n"; // End of if module or All.
    anImplementation << "\t Y" << mod.getName() << "(Y" << a << ", Y" << b << ")->forward(" << inputWardFunctions << ");\n"; // In any case.
  }else if(dimAxe==3){     
    if(mod.getInput()>0 && !mod.isNetward() &&  !mod.isAutonet() && !mod.isHidjac()){        
      if(mod.getTime() > 0){
        anImplementation << "\tnbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() << ",YNBS_" << mod.getName() ;
        anImplementation << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName() << "[Yi][Yj][Yk]->Ystate[0],Y" << mod.getName();
        anImplementation << "[Yi][Yj][Yk]);\n";
      }else{
        anImplementation << "\tnbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() ;
        anImplementation << ",YNBS_" << mod.getName() << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName();
        anImplementation << "[Yi][Yj][Yk]->Ystate,Y" << mod.getName() << "[Yi][Yj][Yk]);\n";
      }
    }
    anImplementation << "\t\t if (nbko>=koleft) return(nbko);\n\t }\n"; // Test max ko reach.
    anImplementation << "\t}\n"; // End of if module or All.
    anImplementation << "\t Y" << mod.getName() << "(Yi, Yj, Yk)->forward(" << inputWardFunctions << ");\n"; // In any case.
  }
}

/**
 * Generation of the automatic feed of the Yting global table for the function forward and backward.
 * For the backward we have to feed also the Ytbeta global table.
 * We manage here also the case of Delta added for the test of the adjoint on the module. 
 * The Delta case is similar to Input but we employ YD instead of YS.
 * We manage here also the case called multi_t. 
 * With multi_t we mean the cases were the trajectories of the modules, connected with the ctin-m connection, are different and
 * we could need to translate the time instant of the input trajectory in the time instant of the out trajectory.
 * This translation appear in the code generation of the file Y2projectname.cpp with the function Ytttt_pdt(....).
 * All the information needed in order to consider all the cases are already stocked in the object connection. 
 * multi_t: if relt is -2 or 2 => little 't' with different trajectories => we have to translate.
 * Otherwise relt is -1 or 1: in this case, if and only if traj(IN) != traj(OUT) then => capital 'T' => we have to adjust on the traj OUT.
 *
 * The generation of code in this method is enaugh similar.
 * For the input we try to generate instruction like:
 * if (1==0 || Yk+1>YA3-1) Yting[12]=0;        else       (if necessary)
 * Yting[12]=YS1_MODULE_NAME( Yi, Yj, Yk+1, YTemps-1);    (for all cases)
 * For Alphas:
 * if (1==0 || Yi-1<0){}  else                            (if necessary)
 * @param anImplementation is the generated file we are writing on.
 * @param ord is the object Order that we are working at the moment of the method call.
 * @param inModule is the module that we are interested on. We work on the connections were the module inModule is the receiver. 
 * @param ibad is the kind of requested generation. ibad is called like this because the possible values are: 'I', 'B', 'A, 'D'. 
 * Input feed (Yting)             if ibad='I' (MD, LT)
 * Beta gradient (Ytbeta)         if ibad='B' (LT)
 * Alpha gradient (YG)            if ibad='A' (Adjoint)
 * Delta (YD)                     if ibad='D' (Adjoint for the module)
 * @param firstAxis is the first axis of the order? Is used in the parallel generation (for the atomic operations) of the backward: 1=i, 2=j, 3=k.
 * @param parallel is this current loop parallel or not. This information is useful for the generation of the adjoint on the backward (ibad='A')
 * in order to create un atomic update of the YG with the Ytbeta.
 */
void Translator::feedward(ostream& anImplementation, Order ord, string inModule, char ibad, int firstAxis, bool parallel){       
  Modul * inMod, *outMod;       // The modules of the Connection beeing analyzed.
  char inType, outType;         // The operator type of the spaces or operators directives binded with the input/output modules.
  int timeCase;                 // In order to manage the cases of translation of the time caused by multi_t (modules connected
                                // with different trajectory coordinate.

  // We scan all the connections. We are interested to the connections where the module is the receiver.
  for(Table<Connection>::iterator con=theConnectionTable.begin(); con != theConnectionTable.end(); con++){
    if(con->getInModule() == inModule){  
      // The modules of the connection.
      inMod = theModulTable.find(con->getInModule());
      outMod = theModulTable.find(con->getOutModule());

      // Opera or space: type of computation.
      if(inMod->isSpaceOrOperator()) inType = theSpaceTable.find(inMod->getSpaceOrOperator())->getType();
      else inType = theOperatorTable.find(inMod->getSpaceOrOperator())->getType();

      if(outMod->isSpaceOrOperator()) outType = theSpaceTable.find(outMod->getSpaceOrOperator())->getType();
      else outType = theOperatorTable.find(outMod->getSpaceOrOperator())->getType();

      // Init of the case.
      timeCase=0;

      // We need the number id of the trajectory. This is equivalent to the position of the trajectory in the table
      // theTrajectoryTable. The number id is used from the generated program, the trajectory at this moment will be
      // addressed with a number id: the idOutTrajectory.
      int idOutTrajectory=0;
      for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){
        if(outMod->getTrajectory() != tra->getName())
          idOutTrajectory++;
        else tra=theTrajectoryTable.end()-1;
      }

      // In function of relt we set the variable Ytps. We analyze all the cases: relative, absolute, case of time translation.
      if(inMod->getTrajectory() == outMod->getTrajectory())    // Case 1, the easiest case: same trajectory.
        timeCase = 1; // We will work directly with YTemps.
      else if(abs(con->getRelt())==2){         
        // Little 't' in connection and different trajectory => translation of the time (including the deplacement).
        // We translate the actual traj IN in the traj OUT.
        timeCase = 2;
        if(con->getRelt()>=1){  //=>2: relative case.
          if(!con->getT())
            anImplementation << "Ytps = Ytttt_pdt(" << idOutTrajectory << ", YTemps, YidTraj);\n";
          else if(con->getT() > 0)
            anImplementation << "Ytps = Ytttt_pdt(" << idOutTrajectory << ", YTemps+" << con->getT() << ", YidTraj);\n";
          else
            anImplementation << "Ytps = Ytttt_pdt(" << idOutTrajectory << ", YTemps" << con->getT() << ", YidTraj);\n";
        }
        if(con->getRelt()<=-1){ //=>-2: absolute case: (Charles comment ==> probleme : comment savoir si la valeur absolue).
          // Charles comment: porte directement sur traj OUT :
          if(1) anImplementation << "Ytps = " << con->getT() << ";";         // ?
          // Charles comment: ou doit etre une traduction de traj IN pour traj OUT :
          else  anImplementation << "Ytps = Ytttt_pdt(" << idOutTrajectory << "," << con->getT() <<" , YidTraj);\n"; // ?
        }
      }else if(con->getRelt()){         
        //=> Charles comment: 'T' => deduire le temps: s'aligner sur celui la trajectoire OUT. 
        timeCase = 3;
        anImplementation << "Ytps = YTabTraj[" << idOutTrajectory << "].toptime;\n";
      }else{  // Here we have con->getRelt() == 0: we have to do something jest for the delta zone, used for the test of the adjoint of a module,
              // and that is temporised (in order to stock the computation of LT ...
        if (ibad=='D'){  
          anImplementation << "\t\t\tYtps = Ytttt_pdt(" << idOutTrajectory << ", YTemps, YidTraj);\n";
          timeCase = 4;
        }
      }

      if( (con->getI() !=0 && con->getReli() ==1) ||  
          (con->getJ() !=0 && con->getRelj() ==1) ||  
          (con->getK() !=0 && con->getRelk() ==1)  ){

        if(ibad!='D') anImplementation << "\t if (1==0";
        else anImplementation << "\t\t if (1==0";

        if(con->getReli()==1){ 
          if(con->getI() < 0)
            anImplementation << " || Yi" << con->getI() << "<0";
          if(con->getI() > 0)
            anImplementation << " || Yi+" << con->getI() << ">YA1_" << ord.getName() << "-1";
        }

        if(con->getRelj()==1){ 
          if(con->getJ() < 0)
            anImplementation << " || Yj" << con->getJ() << "<0";
          if(con->getJ() > 0)
            anImplementation << " || Yj+" << con->getJ() << ">YA2_" << ord.getName() << "-1";
        }

        if(con->getRelk()==1){ 
          if(con->getK() < 0)
            anImplementation << " || Yk" << con->getK() << "<0";
          if(con->getK() > 0)
            anImplementation << " || Yk+" << con->getK() << ">YA3_" << ord.getName() << "-1";
        }

        if(ibad=='I')             // For the inputs.
          anImplementation << ")\n\t Yting[" << con->getIn()-1 << "]=0; \n\t else \n";
        else if (ibad=='D')       // For the deltas, like inputs with a \t more.
          anImplementation << ")\n\t\t Yting[" << con->getIn()-1 << "]=0; \n\t\t else \n";
        else if (ibad=='B')       // For the gradients Beta.
          anImplementation << ")\n\t Ytbeta[" << con->getIn()-1 << "]=0; \n\t else \n";
        else                      // ibad=='A': For the gradients Alpha.
          anImplementation << "){} \n\t else \n";

      }   

      // Else, we have the normal case.
      if(ibad=='I'){                // For the inputs.
        if( (inType == 'B' || inType == 'R' || inType == 'K')  &&   
            (outType != 'B' && outType != 'R' && outType != 'K'))  
          anImplementation << "\t Yting[" << con->getIn()-1 << "]=YW" << con->getOut() << "_" << con->getOutModule() << "(";
        else anImplementation << "\t Yting[" << con->getIn()-1 << "]=YS" << con->getOut() << "_" << con->getOutModule() <<"(";
      }else if (ibad=='D')    // For the deltas (like input but with YD).
        anImplementation << "\t\t\tYting[" << con->getIn()-1 << "]=YD" << con->getOut() << "_" << con->getOutModule() << "(";
      else if (ibad=='B')     // For the gradients Beta.
        anImplementation << "\t Ytbeta[" << con->getIn()-1 << "]=YG" << con->getOut() << "_" << con->getOutModule() << "(";
      else{                   // ibad=='A': case gradients Alpha: backward.
        if(firstAxis==1 && con->getReli() && con->getI() ||
           firstAxis==2 && con->getRelj() && con->getJ() ||
           firstAxis==3 && con->getRelk() && con->getK() ){
          if(parallel){
            anImplementation << "\t #pragma omp atomic\n";
            totalAtomicOperations++;
          }
        }
        anImplementation << "\t YG" << con->getOut() << "_" << con->getOutModule() << "(";
      }

      // Coordinate i axe.
      if(con->getReli()==1){         
        if(con->getI()==0)
          anImplementation << " Yi";
        else if(con->getI() > 0)
          anImplementation << " Yi+" << con->getI();
        else anImplementation << " Yi" << con->getI();
      }
      if(con->getReli()==-1) // Absolute case.
        anImplementation << " " << con->getI()-1;

      // The same for j axe.
      if(con->getRelj()==1){         
        if(con->getJ()==0)
          anImplementation << ", Yj";
        else if(con->getJ() > 0)
          anImplementation << ", Yj+" << con->getJ();
        else
          anImplementation << ", Yj" << con->getJ();
      }
      if(con->getRelj()==-1)
        anImplementation << ", " << con->getJ()-1;

      // The same for k axe.  
      if(con->getRelk()==1){         
        if(con->getK() == 0)
          anImplementation << ", Yk";
        else if(con->getK() > 0)
          anImplementation << ", Yk+" << con->getK();
        else anImplementation << ", Yk" << con->getK();
      }
      if (con->getRelk()==-1)
        anImplementation << ", " << con->getK()-1;

      if( (ibad=='I') &&   
          (inType == 'B' || inType == 'R' || inType == 'K') &&   
          (outType != 'B' && outType != 'R' && outType != 'K')  )
      { // Charles comment: en input, la zone YW ne supporte pas de tempo ... donc pas de coordonnee de temps a constituer.
      }
      else if(timeCase==1){ // We work directly with YTemps.
        if(con->getRelt()==1){  // Relative case.
          if(con->getT()==0)
            anImplementation << ", YTemps";
          else if(con->getT() > 0)
            anImplementation << ", YTemps+" << con->getT();
          else anImplementation << ", YTemps" << con->getT();
        }
        if(con->getRelt()==-1) // Absolute case.
          anImplementation << ", " << con->getT();
      }
      else if(timeCase==2)  // We adjust on the time of the out trajectory.
        anImplementation << ", Ytps";
      else{   // timeCase==3 (ou 0 ou 4) (case timeCase==4 (=>relt==0) we don't manage this here...
        // We adjust on the time of the out trajectory.
        if(con->getRelt()>=1){  //=>2: relative case.
          if(con->getT() == 0)
            anImplementation << ", Ytps";
          else if(con->getT() > 0)
            anImplementation << ", Ytps+" << con->getT();
          else anImplementation << ", Ytps" << con->getT();
        }
        if(con->getRelt()<=-1) //=>-2: Absolute case.
          anImplementation << ", " << con->getT();
      }

      // For Delta non tempo we must have the index of time, that in the case of noward (non tempo) should be 0.
      if(con->getRelt()==0 && ibad=='D'){
        if(outMod->isNoward())
          anImplementation << ", 0";
        else if(timeCase==1)
          anImplementation << ", YTemps";
        else
          anImplementation << ", Ytps";
      }

      if(ibad=='I' || ibad=='D' || ibad=='B') // For Inputs, Delta or Beta gradients.
        anImplementation << ");\n";
      else     // ibad=='A': For the Alpha gradients.
        anImplementation << ") += Ytbeta[" << con->getIn()-1 << "];\n";
    }
  }
}

/**
 * Generation of the code dfward for the module in a grid point.
 * @param anImplementation is the generated file we are writing on.
 * @param ord is the object Order that we are working at the moment of the method call.
 */
// gendfward_maille for Charles
void Translator::dfwardGridGenerator(ostream& anImplementation, Order ord){
  char a, b;
  bool axeTable[3] = {false, false, false}; // A three dimension table that contains true in the relative axe position if the axe token is already met.
  int dimAxe=0;                             // The actual dimension of the axeTable: the number of true elements.

  if(ord.getOrderPhase()==3){ // Trajectories.
    anImplementation << "\nint Ydfward_order_maille(int modop, char *nmmod, int All, int KeKo,  float pdx, float ptol)\n{\n\t int nbko=0;\n";
    for(vector<string>::iterator token=ord.orderTokens.begin(); token < ord.orderTokens.end(); token++)
      anImplementation << "\t nbko += Ydfward_traj_maille_" << *token << "(modop, nmmod, All, KeKo, pdx, ptol);\n";
    anImplementation << "\t return(nbko);\n}\n";
  }else if(ord.getOrderPhase()==2){ // Space in traj.
    anImplementation << "\nint Ydfward_traj_maille_" << ord.getName() << "(int modop, char *nmmod, int All, int KeKo,  float pdx, float ptol)\n{\n";  

    // We find the id of the trajectory necessary to the generated code.
    int idTraj=0;
    Table<Trajectory>::iterator tra=theTrajectoryTable.begin();
    while(tra != theTrajectoryTable.end() && tra->getName() != ord.getName()){
      tra++;
      idTraj++;
    }

    anImplementation << "\t int nbko=0;\n\t if (!Ydftesttt(" << idTraj << ")) return(0);\n";
    for(vector<string>::iterator token=ord.orderTokens.begin(); token < ord.orderTokens.end(); token++)
      anImplementation << "\t nbko += Ydfward_space_maille_" << *token << "(modop, nmmod, All, KeKo, pdx, ptol);\n";
    // In the Charles code there were here the gendfward_opera_maille() function. Is too small so I destroy it.
    //for(Table<Operator>::iterator op=theOperatorTable.end(); op<theOperatorTable.begin(); op--)
    for(Table<Operator>::reverse_iterator op=theOperatorTable.rbegin(); op!=theOperatorTable.rend(); op++)
      anImplementation << "\t nbko += Ydfward_space_maille_" << op->getName() << "(modop, nmmod, All, KeKo, pdx, ptol);\n";
    //dfwardOperaGridGenerator(anImplementation);
    anImplementation << "\t return(nbko);\n}\n";
  }else if(ord.getOrderPhase()==1){
    // Here phase = 1: module level (modinspace).

    anImplementation << "\nint Ydfward_space_maille_" << ord.getName();
    anImplementation << "(int modop, char *nmmod, int All, int KeKo,  float pdx, float ptol)\n{\n\t int nbko=0;\n";

    for(vector<string>::iterator token=ord.orderTokens.begin(); token < ord.orderTokens.end(); token++){
      if      (*token=="YA1") {flagAxe(axeTable, 0, dimAxe);}                        // Part of code  
      else if (*token=="YA2") {flagAxe(axeTable, 1, dimAxe);}                        // necessary to the  
      else if (*token=="YA3") {flagAxe(axeTable, 2, dimAxe);}                        // management of the axes 
      else if (*token=="YB1") {flagAxe(axeTable, 0, dimAxe);}                        // of the modules    
      else if (*token=="YB2") {flagAxe(axeTable, 1, dimAxe);}                        // in function of the order.
      else if (*token=="YB3") {flagAxe(axeTable, 2, dimAxe);}
      else if (*token=="forder" || *token== "FORDER"){                
        unflagAxe(axeTable, ord, token, dimAxe);
      }else if(theModulTable.find(*token)){ // On ne s'interesse qu'aux modules ... 

        Modul *mod=theModulTable.find(*token);
        // In these cases we generate the dfward call code for this module.
        if(!mod->isNoward() && mod->getOutput()>0 ){
          // Research of the axes ... 
          a=b=' ';
          searchAxes(axeTable, &a, &b);

          // Generation of the code dfward for the module.
          dfwardGeneratorModule(anImplementation, ord, *mod, dimAxe, a, b);
        }
      }
    }
    anImplementation << "\t return(nbko);\n}\n";
  }
}

// gendfward_opera_maille for Yao8.cs: no more needed, it is considered too small for a new method.

/**
 * Code generation of the dfward in the directive order of a module. 
 * This generation allows to test the code of the backward functions by the call of Ytestdf_() function and the check of ko. 
 * @param anImplementation is the generated file we are writing on.
 * @param ord is the object Order that we are working at the moment of the method call.
 * @param mod is the module that we are interested for the dfward generation. 
 * @param dimAxe is the actual dimension of the axeTable: the number of true elements.
 * @param a is the letter that represent the first axe. 
 * @param b is the letter that represent the second axe.
 */
// gendfward_mod for Yao8.c
void Translator::dfwardGeneratorModule(ostream& anImplementation, Order ord, Modul mod, int dimAxe, char a, char b){
  ostringstream streamInputWardFunctions; //It's useful in order to generate the string inputWardFunctions.
  string inputWardFunctions;              //Parameters in input for functions *ward (Yting[i] sequence in Y2_project_file).

  // Yting feed for this module: we create all the code "Yting[]=Y..." in the feedward.
  feedward(anImplementation, ord, mod.getName(), 'I', 0, false);

  // Test sur que le module ou All.
  anImplementation << "\tif (!strcmp(nmmod, \"" << mod.getName() << "\") || All)\n\t{\n";

  // Charles comment--> remarque1 : Faut-il faire un forward avant ou apres pour propager les etats (YS) ? Mais en fait,
  // est-ce bien utile d'en rajouter puisque testdf en fait des forwards (a un dx pres) !
  // sauf pour les RN (que l'on ne test pas et pour lesquels il faut donc quand meme propager) !
  // (nb: l'utilisateur est sensed avoir valorised les etats initiaux, De plus, il peut
  // les propager avec un forward s'il veut tester sur un pas de temps particulier)
  // oui mais remarque2 : Si le test n'a ete demanded que pour un module, le testdf des autres ne
  // sera pas fait et donc pas non plus leur forward ... so: faire le forward systematiquement pour tous les modules.

  // Creation of the input parameters for the *ward function if necessary (so if not autonet or array, in this case is not useful).
  streamInputWardFunctions.str("");
  inputWardFunctions = "";
  if(!mod.isAutonet() && !mod.isArray()){  
    for(int i=0; i<mod.getInput(); ++i) streamInputWardFunctions <<" Yting[" << i << "],";
    inputWardFunctions = streamInputWardFunctions.str();
    if(inputWardFunctions.size()) 
      inputWardFunctions.replace(inputWardFunctions.size()-1, 1, " ");
  }

  // Call of the testdf function according to the axe dimension; 
  // Charles comment: nb: pas de test pour les modules sans input, les RN, les hidjac mais il faut quand meme faire un forward apres. 
  if(dimAxe==1){     
    if(mod.getInput()>0 && !mod.isNetward() &&  !mod.isAutonet() && !mod.isHidjac()){        
      if(mod.getTime() > 0){
        anImplementation << "\t nbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() ;
        anImplementation << ",YNBS_" << mod.getName() << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName();
        anImplementation << "[Y" << a << "]->Ystate[0],Y" << mod.getName() << "[Y" << a << "]);\n";
      }else{
        anImplementation << "\t nbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() ;
        anImplementation << ",YNBS_" << mod.getName() << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName() << "[Y" << a;
        anImplementation << "]->Ystate,Y" << mod.getName() << "[Y" << a << "]);\n";
      }
    } // cf !^ remarks.
    anImplementation << "\t}\n"; // End of the if module or All.
    anImplementation << "\t Y" << mod.getName() << "(Y" << a << ")->forward(" << inputWardFunctions << ");\n"; // In any case 
  }else if(dimAxe==2){     
    if(mod.getInput()>0 && !mod.isNetward() &&  !mod.isAutonet() && !mod.isHidjac()){        
      if(mod.getTime() > 0){
        anImplementation << "\t nbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() << ",YNBS_" << mod.getName() ;
        anImplementation << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName() << "[Y" << a << "][Y" << b;
        anImplementation << "]->Ystate[0],Y" << mod.getName() << "[Y" << a << "][Y" << b << "]);\n";
      }else{
        anImplementation << "\t nbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() ;
        anImplementation << ",YNBS_" << mod.getName() << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName() ;
        anImplementation << "[Y" << a << "][Y" << b << "]->Ystate,Y" << mod.getName() << "[Y" << a << "][Y" << b << "]);\n";
      }
    } // cf !^ remarks. 
    anImplementation << "\t}\n"; // End of the if module or All.
    anImplementation << "\t Y" << mod.getName() << "(Y" << a << ", Y" << b << ")->forward(" << inputWardFunctions << ");\n"; // In any case.
  }else if(dimAxe==3){     
    if(mod.getInput()>0 && !mod.isNetward() &&  !mod.isAutonet() && !mod.isHidjac()){        
      if(mod.getTime() > 0){
        anImplementation << "\t nbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() << ",YNBS_" << mod.getName() ;
        anImplementation << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName() << "[Yi][Yj][Yk]->Ystate[0],Y" << mod.getName()<<"[Yi][Yj][Yk]);\n";
      }else{
        anImplementation << "\t nbko += Ytestdf_" << mod.getName() << "(modop,KeKo,pdx,ptol,YNBI_" << mod.getName() << ",YNBS_" << mod.getName() ;
        anImplementation << ",\"" << mod.getName() << "\",Yting,Y" << mod.getName() << "[Yi][Yj][Yk]->Ystate,Y" << mod.getName() << "[Yi][Yj][Yk]);\n";
      }
    } // cf !^ remarks.
    anImplementation << "\t}\n"; // End of the if module or All.
    anImplementation << "\t Y" << mod.getName() << "(Yi, Yj, Yk)->forward(" << inputWardFunctions << ");\n"; // In any case.
  }else
    ENFORCE(false)("fail: sorry, [4] unpredictable error dimaxe=")(dimAxe)(" \n");
}

/**
 * Manages the code generation of the functions *ward in the multi context. 
 * This generation is relative only to the spaceintraj option of the order directive (phase2 of the order) 
 * and for the last trajectories generation (phase3 of the order).
 * The ward to be generated in the file Y2projectName.h are: forward, linward, dfward (if GRADTEST option setted) and backward.
 * This method is called from the method generateCode.
 * @param anImplementation is the generated file we are writing on.
 * @param wardKind the kind of *ward to be generated.
 * @param ord is the object Order that we are working at the moment of the method call.
 */
// genorder_multi for Yao8.c
void Translator::orderGeneratorMulti(ostream& anImplementation, string wardKind, Order ord){ 
  // Phase 2: block (spaceintraj) traj that contains spaces.
  string forward("forward"), linward("linward"), dfward("dfward"), backward("backward"), flinward("flinward"); // Like this is more confortable.
  // Phase 3: a final block that contains all trajectories needed for particular generation at the end of the directive order.

  if(ord.getOrderPhase()==2){  // Spaceintraj.
    if(wardKind==dfward){ // With dfward there are parametres.
      // We find the id of the trajectory necessary to the generated code.
      int idTraj=0;
      Table<Trajectory>::iterator tra=theTrajectoryTable.begin();
      while(tra != theTrajectoryTable.end() && tra->getName() != ord.getName()){
        tra++;
        idTraj++;
      }
      anImplementation << "\nint Ydfward_traj_" << ord.getName() << "(int modop, char *nmmod, int All, int KeKo, int koleft,";
      anImplementation << "float pdx, float ptol, int yi, int yj, int yk)\n{\n";
      anImplementation << "\t int nbko=0;\n\t if (!Ydftesttt(" << idTraj << ")) return(0);\n";
    }else{  
      anImplementation << "\nint Y" << wardKind << "_traj_" << ord.getName() << "(int nbp)\n{\n";
      if(wardKind==forward) anImplementation << "\tYcurward=FORWARD;\n";
      if(wardKind==linward) anImplementation << "\tYcurward=LINWARD;\n";
      if(wardKind==backward) anImplementation << "\tYcurward=BACKWARD;\n";
    }
    for(vector<string>::iterator token=ord.orderTokens.begin(); token < ord.orderTokens.end(); token++){
      Space * spa = theSpaceTable.find(*token);
      ENFORCENOT(!spa->isCounterOrderHeader())  // Test: has this space already been in a modinspace (so in a modinspace header).
        ("order spaceintraj: no modinspace declared for space ")(*token)(" \n");
      if(wardKind==forward){                    // Test only on forward: has this space already been in a spaceintraj (so in a spaceintraj body).
        ENFORCENOT(spa->isCounterOrderBody())("order spaceintraj: ")(*token)(" space already appears in a trajectory\n");
        spa->setCounterOrderBody(true); // Flag of the counter.
      }
      ENFORCENOT(spa->getParent()->getName() != ord.getName()) // Test: is this space linked on this trajectory.
        ("order spaceintraj: ")(*token)(" space is not on ")(ord.getName())(" trajectory\n");

      if(wardKind==dfward) // With dfward there are parametres.
        anImplementation << "\t nbko += Ydfward_space_" << *token << "(modop, nmmod, All, KeKo, koleft, pdx, ptol, yi, yj, yk);\n";
      else anImplementation << "\t Y" << wardKind << "_space_" << *token << "();\n";
    }
  }else if(ord.getOrderPhase()==3){  // Final block that contains all trajectories.
    // Charles comment: (nb PLM on ne traite pas de trajectoires ni parallele ni temporisees, mais si cela devait, y'aurait surement ARAR).
    if(wardKind==dfward){ // With dfward there are parametres.
      anImplementation << "\nint Ydfward_order(int modop, char *nmmod, int All, int KeKo, int koleft, float pdx, float ptol, int yi, ";
      anImplementation << "int yj, int yk)\n{\n\t int nbko=0;\n";
    }else anImplementation << "\nint Y" << wardKind << "_order()\n{\n"; // Ex: Yforward_order (idem *ward).
    for(vector<string>::iterator token=ord.orderTokens.begin(); token < ord.orderTokens.end(); token++)
      if(wardKind==dfward) // With dfward there are parametres.
        anImplementation << "\t nbko += Ydfward_traj_" << *token << "(modop, nmmod, All, KeKo, koleft, pdx, ptol, yi, yj, yk);\n";
      else anImplementation << "\t Y" << wardKind << "_traj_" << *token << "(0);\n";
  }

  if(wardKind==dfward){  
    // In the Charles code there were here the gendfward_opera() function. Is too small so I destroy it.
    for(Table<Operator>::reverse_iterator op=theOperatorTable.rbegin(); op!=theOperatorTable.rend(); op++)
      anImplementation << "\t nbko += Ydfward_space_" << op->getName() << "(modop, nmmod, All, KeKo, koleft, pdx, ptol, yi, yj, yk);\n";
    anImplementation << "\t return(nbko);\n}\n"; // With dfward we return nbko
  }
  else anImplementation << "\t return(0);\n}\n";
}

/**
 * Used at the end of the Order generation to generate some functions relative to the operators.
 * We produce here the *ward of the operators. At the moment we generate only forward_operator, backward_operator and linward_operator 
 * @param anImplementation is the generated file we are writing on.
 */
void Translator::wardOperatorGenerator(ostream &anImplementation){ 
  // Yforward_operator. 
  anImplementation << "\nvoid Yforward_operator (char type) \n{\t";
  for(Table<Operator>::iterator op=theOperatorTable.begin(); op!=theOperatorTable.end(); op++){               
    anImplementation << "\n\tif ((YTabOpera[Yid_" << op->getName() << "].type==type || type=='*')  && YTabOpera[Yid_";
    anImplementation << op->getName() << "].isactiv) Yforward_space_" << op->getName() << "();";
  }
  anImplementation << "\n}";

  // Ylinward_operator.
  if(theContext.isGradTestOrIncremental()){  
    anImplementation << "\nvoid Ylinward_operator (char type) \n{\t";
    for(Table<Operator>::iterator op=theOperatorTable.begin(); op!=theOperatorTable.end(); op++){               
      anImplementation << "\n\tif ((YTabOpera[Yid_" << op->getName() << "].type==type || type=='*')  && YTabOpera[Yid_";
      anImplementation << op->getName() << "].isactiv) Ylinward_space_" << op->getName() << "();";
    }
    anImplementation << "\n}";
  }

  // Ybackward_operator.
  anImplementation << "\nvoid Ybackward_operator (char type) \n{\t";
  for(Table<Operator>::reverse_iterator op=theOperatorTable.rbegin(); op!=theOperatorTable.rend(); op++){               
    anImplementation << "\n\tif ((YTabOpera[Yid_" << op->getName() << "].type==type || type=='*')  && YTabOpera[Yid_";
    anImplementation << op->getName() << "].isactiv) Ybackward_space_" << op->getName() << "();";
  }
  anImplementation << "\n}";
}

/**
 * Code generation for the Function directive.
 * @param anImplementation is the generated file we are writing on.
 * @param aFunctionTable the table that contains all the Functions.
 */
void Translator::generateCode(ostream& anImplementation, Table<Function>& aFunctionTable){
  Table<Function>::iterator funct;
  if(aFunctionTable.size()>0){ // The first time.
    funct=aFunctionTable.begin();
    anImplementation << "\n\n// € € € € € € € € LES FONCTIONS UTILISATEUR ... : \n";
    anImplementation << "int Yuser_call (int argc, char *argv[]) \n{\n\t int codret=1;";
    anImplementation << "\n\t if (strcmp(argv[0], \"" << funct->getName() << "\") == 0)\n\t\t " << funct->getName();
    if(funct->isParameterized())
      anImplementation << "(argc, argv);"; 
    else anImplementation << "();"; 
  }
  if(aFunctionTable.size()>1){ // From the second time we need "else if" in the generated code.
    for(funct=aFunctionTable.begin()+1; funct < aFunctionTable.end(); funct++){
      anImplementation << "\n\t else if (strcmp(argv[0], \"" << funct->getName() << "\") == 0)\n\t\t " << funct->getName(); 
      if(funct->isParameterized())
        anImplementation << "(argc, argv);";
      else anImplementation << "();"; 
    }
  }
}

/**
 * Last cronological code generation. We have finished the generation of each directive. 
 * Here we have some generation that we could not perform before.
 * @param aDeclaration is the generated file we are writing on.
 * @param anImplementation is the generated file we are writing on.
 */
void Translator::generateCode(ostream& aDeclaration, ostream& anImplementation){
  ostringstream  bufwrk; // A stream buffer to perform some work with strings.

  // 1) Treatment for trajectories.
  //------------------------------------------------------------------------
  aDeclaration << "\n/*------------- DUE TO MULTI TRAJECTOIRIES --------------*/\n";
  // Note:  a trajectory could not be present in any Order spaceintraj. 
  //        For example the user could want to netralize it if on the trajectory are defined only modules noward. In this case:
  //       -> non prototype;
  //       -> *ward()=NULL
  //       -> isactiv=0 (rdg: not changeable if fward==NULL).
  aDeclaration << "#define YNBTRAJ        " << theTrajectoryTable.size() << " \n";
  //1.1) Prototype of the functions needed to go through the trajectories and other... 
  for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++)
    if(tra->isCounterOrder()){ // If not spaceintraj => we will not have a prototype. 
      aDeclaration << "int Yforward_traj_" << tra->getName() << "(int nbp);\n";
      aDeclaration << "int Ybackward_traj_" << tra->getName() << "(int nbp);\n";
      if(theContext.isGradTestOrIncremental()) aDeclaration << "int Ylinward_traj_" << tra->getName() << "(int nbp);\n";
      if(theContext.isGradTest()){ 
        aDeclaration << "int Ydfward_traj_" << tra->getName() << "(int modop, char *nmmod, int All, int KeKo, int koleft,";
        aDeclaration << "float pdx, float ptol, int yi, int yj, int yk);\n";
      }
    }
  if(theContext.isGradTest()) aDeclaration << "int Ydftestijkt(int imod);\nint Ydftesttt(int itraj);\n";

  aDeclaration << "\n/*------- GENERATION DU TABLEAU DES TRAJECTOIRES --------*/\n";
  // 1.2) Creation of the table of trajectories.
  aDeclaration << "struct Yst_traj YTabTraj[" << theTrajectoryTable.size() << "] = {\n";
  for(Table<Trajectory>::iterator tra=theTrajectoryTable.begin(); tra != theTrajectoryTable.end(); tra++){   
    bufwrk.str("");
    if(tra->isCounterOrder()){  
      if(theContext.isGradTestOrIncremental() && theContext.isGradTest()){  
        bufwrk << "Yforward_traj_" << tra->getName() << ", Ybackward_traj_" << tra->getName() << ", Ylinward_traj_";
        bufwrk << tra->getName() << ", Ydfward_traj_" << tra->getName() << ", 1";
      }else if(theContext.isGradTestOrIncremental())
        bufwrk << "Yforward_traj_" << tra->getName() << ", Ybackward_traj_" << tra->getName() << ", Ylinward_traj_" << tra->getName() << ", NULL, 1";
      else if(theContext.isGradTest())
        bufwrk << "Yforward_traj_" << tra->getName() << ", Ybackward_traj_" << tra->getName() << ", NULL, Ydfward_traj_" << tra->getName() << ", 1";
      else bufwrk << "Yforward_traj_" << tra->getName() << ", Ybackward_traj_" << tra->getName() << ", NULL, NULL, 1";
    }else // Non spaceintraj => NULL everywhere and inactive.
      bufwrk << "NULL, NULL, NULL, NULL, 0";

    ENFORCENOT(bufwrk.str().size() >= LG_MAX_STRING)("-->buffer not big enough for trajectories array; see your Yao administrator\n");

    // The fixed and setprecision option are needed only for equality with Charles code: we could not put it.
    aDeclaration << "\t{\"" << tra->getName() << "\", '" << tra->getType() << "', " << tra->getBoot() << ", " << fixed << setprecision(6);
    aDeclaration << tra->getOffset() << ", " << tra->getStep() << ", " << tra->getOffset() << ", " << tra->getBoot() << ", " << tra->getSize();
    aDeclaration << ", " << tra->getOffset() + tra->getStep() * tra->getSize(); //stoptime initial (sachant begintime=0)
    aDeclaration << ", " << bufwrk.str() << "},\n";
  }
  aDeclaration << "};\n";

  //2) Creation of the spaces table.
  //------------------------------------------------------------------------
  aDeclaration << "\n/*------- GENERATION DU TABLEAU DES ESPACES --------*/\n";
  aDeclaration << "#define YNBSPACE       " << theSpaceTable.size() << " \n";
  aDeclaration << "struct Yst_space YTabSpace[" << theSpaceTable.size() << "] = {\n";
  for(Table<Space>::iterator spa=theSpaceTable.begin(); spa != theSpaceTable.end(); spa++){
    aDeclaration << "\t{\"" << spa->getName() << "\", '" << spa->getProperty(3) << "', " << spa->getYA(1) << ", " << spa->getYA(2) << ", ";
    aDeclaration << spa->getYA(3) << ", \"" << spa->getParent()->getName() << "\"},\n";
  }
  aDeclaration << "};\n";

  // 2) Creation of the operators table.
  //------------------------------------------------------------------------
  aDeclaration << "\n/*------ GENERATION DU TABLEAU DES OPERATEURS -------*/\n";
  aDeclaration << "#define YNBOPERA       " << theOperatorTable.size() << " \n";
  aDeclaration << "struct Yst_opera YTabOpera[" << theOperatorTable.size() << "] = {\n";
  for(Table<Operator>::iterator op=theOperatorTable.begin(); op!=theOperatorTable.end(); op++){               
    aDeclaration << "\t{\"" << op->getName() << "\", '" << op->getProperty(3) << "', " << op->getYA(1) << ", " << op->getYA(2);
    aDeclaration << ", " << op->getYA(3) << ", \"" << op->getParent()->getName() << "\", 0},\n";
  }
  aDeclaration << "};\n";

  // 3) Creation of the modules table.
  //------------------------------------------------------------------------
  aDeclaration << "\n/*------- GENERATION D'UN TABLEAU d'ACCES AUX MODULES --------*/\n";
  aDeclaration << "#define YNBMODUL       " << theModulTable.size() << " \n";
  aDeclaration << "struct Yst_modul YTabMod[" << theModulTable.size() << "] = {\n";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
    aDeclaration << "\t{\"" << mod->getName() << "\", *Y" << mod->getName() << ", " << mod->getNbAxes() << ", " << mod->getYA(1);
    aDeclaration << ", " << mod->getYA(2) << ", " << mod->getYA(3) << ", " << mod->getInput() << ", " << mod->getOutput();
    aDeclaration << ", " << mod->getTime() << ", " << mod->isCout() << ", " << mod->isTarget() << ", " << mod->getBeginTarget() << scientific;
    aDeclaration << ", " << mod->getEndTarget() << ", " << mod->getScoef() << ", " << mod->getBcoef();
    aDeclaration << ", " << mod->getPcoef() << ", " << mod->isCounterOrder() << ", \"" << mod->getSpaceOrOperator() << "\"},\n";
  }
  aDeclaration << "};\n";

  // Searching anomalies. We look for ghost and parasit module.
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
    int predecessorNumber=0, successorNumber=0;
    for(Table<Connection>::iterator con=theConnectionTable.begin(); con != theConnectionTable.end(); con++){
      predecessorNumber += (mod->getName() == con->getInModule());
      successorNumber += (mod->getName() == con->getOutModule());
    }

    if(predecessorNumber + successorNumber <=0) // Module without connections.
      if(mod->isCounterOrder())
        cout << "Warning: Ghost module found --> " << mod->getName() << " \n";
      else cout << "Warning: Parasit module found --> " << mod->getName() << " \n";
  }

  // 3.2) Creation of the flag association module/operateurs table that will allow to guide from the modules the trigger of the operators.
  // ------------------------------------------------------------------------
  // 3.2.1) For the modules cout : table YTabMocop.
  aDeclaration << "\n/*------- GENERATION TABLEAU COUT_MODULES/OPERA --------*/\n";
  aDeclaration << "short   YTabMocop[YNBMODUL][YNBOPERA] = {\n";
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++){
    bufwrk.str("");
    int count=0, i;
    for(Table<Operator>::iterator op=theOperatorTable.begin(); op!=theOperatorTable.end(); op++){ 
      i=0;
      for(vector<string>::iterator listOperator=mod->getLopera().begin(); listOperator!=mod->getLopera().end(); listOperator++){
        // It is very strange: *listOperator doesn't work! So I use *(mod->getLopera().begin() + i) and it works. 
        // Anyway we cannot have more then one element in the vector in this YAO version so we could have *mod->getLopera().begin().
        // if(*listOperator == op->getName()){
        if(*(mod->getLopera().begin() + i) == op->getName()){
          bufwrk << " Yid_" << op->getName() << ",";
          ENFORCENOT(bufwrk.str().size()>=LG_MAX_STRING)("-->buffer not big enough for operator array; see your Yao administrator\n");
          ++count;
          i++;
        }
      } // End list lopera.
    } 
    for(int i=count; i<theOperatorTable.size(); ++i){
      bufwrk << "  -1,";
      ENFORCENOT(bufwrk.str().size()>=LG_MAX_STRING)("-->buffer not big enough for operator array; see your Yao administrator\n");
    }
    if(bufwrk.str().size()>0){
      string str = bufwrk.str();
      str.replace(str.size()-1, 1, " ");
      aDeclaration << "\t{ " << str << " },\n";
    }
    else aDeclaration << "\t{  },\n";
  } // End for Modules.
  aDeclaration << "};\n";

  // 4) Creation of the constants table.
  // ------------------------------------------------------------------------
  // Remark: the constant Y3_M is a particular case of constant. It is in the table of constant but we have already generate all the necessary for it.
  // We exclude the generation relative to this constant in this phase.
  aDeclaration << "\n//----- GENERATION d'UN TABLEAU de DEFINITIONS de VALEURS -----\n";
  aDeclaration << "#define YNBDEFVAL      " << theConstantTable.size()-1 << " \n";
  aDeclaration << "struct Yst_defval YTabDefval[" << theConstantTable.size()-1 << "] = {\n";
  for(Table<Constant>::const_iterator cons = theConstantTable.begin(); cons != theConstantTable.end(); ++cons)
    if(cons->getName() != string("Y3_M")) 
      aDeclaration << "\t{\"" << cons->getName() << "\", \"" << cons->getText() << "\"},\n";
  aDeclaration << "};\n";

  // 5) Automatic replacement of the directives include and module: 
  // -----------------------------------------------------------------------
  // (we have to have a .h for each module!).
  // Charles comment: avant, ce code etait genere en fin de traitement des modules, mais il a
  // du etre deplaced apres la generation des tableaux car les hat et les modules
  // doivent pouvoir s'en servir (des tableaux) qui doivent donc etre declares avant.
  aDeclaration << "\n//€ € € € GENERATION AUTOMATIQUE DES include € € € € € € € € € € €\n";
  for(vector<string>::const_iterator hat = theHeaderList.begin(); hat != theHeaderList.end(); ++hat) // The hats.h
    aDeclaration << "#include \"" << *hat << "\" \n";

  // For each module (excepty the autonet, the clones and the noward): 
  for(Table<Modul>::iterator mod=theModulTable.begin(); mod != theModulTable.end(); mod++)
    if(!mod->isAutonet() && !mod->isCloned() && !mod->isNoward()){
      aDeclaration << "\n";
      aDeclaration << "#define  forward  void " << mod->getName() << "::forward \n";
      aDeclaration << "#define  backward void " << mod->getName() << "::backward\n";
      aDeclaration << "#define  flinward void " << mod->getName() << "::flinward\n";

      bufwrk.str("");  
      if(mod->getTime())
        bufwrk << "[" << YTEMPS << "]";

      for(int w2=0; w2<mod->getOutput() && w2<NB_MAX_MACRO; ++w2){               
        aDeclaration << "#define  YS" << w2+1 << "Y " << YSTATE << bufwrk.str() <<"[" << w2 <<"] \n";
        aDeclaration << "#define  YS" << w2+1 << "  " << YSTATE << bufwrk.str() <<"[" << w2 <<"] \n";
        aDeclaration << "#define  YG" << w2+1 << "  " << YGRAD << bufwrk.str() <<"[" << w2 <<"] \n";
      }
      aDeclaration << "#include \"" << mod->getName() << ".h\" \n";
      for(int w2=0; w2<mod->getOutput() && w2<NB_MAX_MACRO; ++w2){               
        aDeclaration << "#undef   YS" << w2+1 << "Y  \n";
        aDeclaration << "#undef   YS" << w2+1 << "   \n";
        aDeclaration << "#undef   YG" << w2+1 << "   \n";
      }

      aDeclaration << "#undef   forward \n";
      aDeclaration << "#undef   backward\n";
      aDeclaration << "#undef   flinward\n";
    }

  // 6) Creation of a function Yuser_call empty in the case of no user functions. 
  // ---------------------------------------------------------------------------
  if(!theFunctionTable.size()){  
    anImplementation << "\n\n// € € € € € € € € LES FONCTIONS UTILISATEUR ... : \n";
    anImplementation << "int Yuser_call (int argc, char *argv[]) \n{\n\t int codret=0;\n\t if(1) codret=0;";
  }
  // This is the end of the user functions in both cases if functions exist or not:
  anImplementation << "\n\t else codret=0;\n\t return(codret);\n}\n";

  aDeclaration << "\n//-------------- end Yao generation -----------------\n";
  anImplementation << "\n//-------------- end Yao generation -----------------\n";
}


/**
 * Is the nested loop parallel or not? This method answer to this question.
 * These are three examples of the vector orderTokens contained by the object Order, each string of the line is called token:
 * 1) order YA1 YA2 M1 M2 M3 forder
 * 2) order YA1 order YA2 M1 forder M2 forder
 * 3) order YA1 YB2 M1 M2 forder order YB1 YA2 M3 M4 forder
 * The last example is interesting because we can see that there are more than one nested loop generated,
 * the first one from the first order to the second order and the second for the las couple order-forder.
 * The objective of this method is to control that ONE nested loop can be parallelized. We do not scan all the vector in general.
 * It scans one interval order-forder and check all the connection between the modules encountered in this interval.
 * The condition of parallelization came from the extern loop index (it may be i, j or k) that we call Y and the time of the the connection.
 * The connection is defined as:
 * M1 from M2 i+ci j+cj k+ck t+ct 
 * with ci,cj,ck relative integer and ct<=0.
 * So we call the extern loop in general Y+cy.
 * The bad condition is that cy!=0 and ct==0. 
 * With these conditions we can perform a domain decomposition and parallelize the forward code.
 * This is a frequent case because the conditions has to be verified only for the modules in the current interval order-forder.
 * @param token is the current scanning element of the orderTokens vector.
 * @param ord is the current order analyzed.
 * @param wardKind the kind of *ward to be generated: forward or backward here.
 */
bool Translator::parallelVerification(vector<string>::iterator token, Order ord, string wardKind){
  bool axes[3] = {false, false, false};   // A three dimension table that contains true in the relative axe position if the axe token is already met.
  int dAxe=0;                             // The actual dimension of the axeTable: the number of true elements.
  bool ret;                               // Return value.
  int firstAxis=0;                        // Remember the first axis after the first order (the order with dimAxe=0).
  bool inOk, outOk;                       // Used to verify the connection. inOk/outOk is true if the in/out module is contained in the interval.
  bool spaceOrOperator = true;            // Used in order to understand if we are managing a Space (true) or an Operator (false).
  vector<string> modulesVector;           // Set of the modules contained in the current interval.
  vector<Connection> connectionVector;    // Set of the connections to be tested.

  // We search the kind of order: Operator or Space?
  string name = ord.getName();
  for(Table<Operator>::const_iterator op = theOperatorTable.begin(); op != theOperatorTable.end(); ++op)
    if(name == op->getName()){
      spaceOrOperator = false;
      break;
    }

  // We analyse all the tokens and separate the modules contained in the current interval.
  while(true){
    token++;
    if(*token == "YA1" || *token == "YB1"){
      if(dAxe==0) firstAxis=1;
      flagAxe(axes, 0, dAxe); 
    }
    else if(*token == "YA2" || *token == "YB2"){
      if(dAxe==0) firstAxis=2;
      flagAxe(axes, 1, dAxe);
    }
    else if(*token == "YA3" || *token == "YB3"){
      if(dAxe==0) firstAxis=3;
      flagAxe(axes, 2, dAxe); 
    }else{
      if(*token == "order" || *token == "ORDER")
        continue;
      if(*token == "forder" || *token == "FORDER"){               
//      cout << endl<<"The value of the axeTable BEFORE the unflag:"<< axes[0]<<" "<<axes[1]<<" "<<axes[2]<<endl; // For see/debug. 
        unflagAxe(axes, NULL, token, dAxe);  
//      cout <<endl<<"The value of the axeTable AFTER the unflag: "<<axes[0]<<" "<<axes[1]<<" "<<axes[2]<<endl; // For see/debug.
        if(dAxe==0) break;
      }else{ // Here the token is a module.
        modulesVector.push_back(*token);
      }
    }
  }

  // PRIMO ERRORE PARALLELISMO BACKWARD-----------------------
  // The backward is always parallel exept in the case tho parallelism option is not enabled and if the axis is not big enough
  /*if(wardKind=="backward"){
    ret = theContext.isParallel() && theSpaceTable.find(ord.getName())->getYA(firstAxis)>1;
    if(ret==true){
      parallelBackwardLoops++;
      parallelBackwardModules += modulesVector.size();
    }
    return ret;
  }*/

  // Scan of all theTableConnection and the selection of the connections that we have to test.
  // A connection is to be tested if both the modules are in the interval order-forder.
  for(vector<Connection>::iterator conIt=theConnectionTable.begin(); conIt < theConnectionTable.end(); conIt++){
    inOk=false;
    outOk=false;

    // Check of the in module
    for(vector<string>::iterator modIt=modulesVector.begin(); modIt!=modulesVector.end(); modIt++){
      if(conIt->getInModule() == *modIt){
        inOk=true;
        break;
      }
    }

    // Check of the out module
    if(inOk==true)
      for(vector<string>::iterator modIt=modulesVector.begin(); modIt!=modulesVector.end(); modIt++){
        if(conIt->getOutModule() == *modIt){
          outOk=true;
          break;
        }
      }

    if(inOk && outOk)
      connectionVector.push_back(*conIt);
  }

  //-------------->Controllo!
  //if(connectionVector.size() == theConnectionTable.size())
  //  cout << endl << "Sono uguali, size: " << connectionVector.size() << endl;
  //else cout << endl << "Sono diversi, size: " << connectionVector.size() << endl;

  // Final test of the connections: ct=0 && cY!=0.
  // We consider only relative connections. The absolute connections in the vector connectionVector are always not parallelizable.
  // The connection value cY is between 1 and YX1 so they are always detected by the condition defined.
  ret=true;
  for(vector<Connection>::iterator conIt=connectionVector.begin(); conIt < connectionVector.end(); conIt++){
    if(firstAxis==1 && !conIt->getT() && conIt->getI()){ 
    //cout << "   conIt->getName()" << conIt->getName() << endl;
      ret=false; break; }
    else if(firstAxis==2 && !conIt->getT() && conIt->getJ()){ 
    //cout << "   conIt->getName()" << conIt->getName() << endl;
      ret=false; break; }
    else if(firstAxis==3 && !conIt->getT() && conIt->getK()){ 
    //cout << "   conIt->getName()" << conIt->getName() << endl;
      ret=false; break; }
  }

  // (theSpaceTable.find(ord.getName())->getYA(1) > 1) the axis that we want to decompose 
  // is big than 1 otherwise the parallelism make no sense.
  if((wardKind=="forward" || wardKind=="backward") && ret){
    if(spaceOrOperator){
      if(theSpaceTable.find(ord.getName())->getYA(firstAxis)<=1){
        ret=false;
        cout << endl << "The axis of the domain decomposition for the order modinspace " << ord.getName() 
          << " is not big enaugh: " << theSpaceTable.find(ord.getName())->getYA(firstAxis) << endl
          << "the parallelization is not useful and because of that the parallel code is not generated." << endl;
      }
    }else if(theOperatorTable.find(ord.getName())->getYA(firstAxis)<=1){
      ret=false;
      cout << endl << "The axis of the domain decomposition for the order modinspace " << ord.getName() 
        << " is not big enaugh: " << theOperatorTable.find(ord.getName())->getYA(firstAxis) << endl
        << "the parallelization is not useful and because of that the parallel code is not generated." << endl;
    }
  }

  //-------------------->
  //  for(vector<string>::iterator t=modulesVector.begin(); t < modulesVector.end(); t++){cout << "mod:   " << *t << endl;  }

  if(wardKind=="forward"){
    if(ret==true){
      parallelForwardLoops++;
      parallelForwardModules += modulesVector.size();
    }
    totalLoops++;
    totalModulesInOrders += modulesVector.size(); 
  }
//  cout << "-------------------Sono parallelo?: " << (ret && theContext.isParallel()) << endl << endl << endl;
  return ret && theContext.isParallel();
}