== Tutorial Title ==

[[TableOfContents(3)]]

=== Description ===
 * This file will describe the basic steps/pathway that happens after hitting the compile button on a Constitutive model which includes a dynamic variable tied to an Active Tension model.

=== The Compile Button ===
 * You want to compile the Constitutive model, after submitting the corresponding Active Tension (AT) model.
 * The compile button is at: pcty/client/forms/!MatModelForm.py, when hit, it runs the '''generateCode''' method within the same file.

=== generateCode ===
 * This is the controlling method that handles source code generation, the steps it takes are:
   * Parses equation meta data file, after moving it to a temp directory, for the Constitutive model and assigns the variables and equations to individual lists. (parse_table_file from sympy_to_c.py handles the parsing). We then have the following lists: scalar, vector, tensor, dynamic_vars, rpars, and equations.  
   * The variable name mapping is as follows:
      || Eqn Editor Name(s) || List Name ||
      || Independent || scalar ||
      || Dependent and tensor|| tensor ||
      || Dynamic or time_dependent || dynamic ||
      || Parameters || rpars ||
      || n/a  || vector - currently hard coded as: ['rpar_mat', 'rpar_at', 'y'] ||
   * If we find any dynamic variables within the Constitutive model, we then get the other model's variables and equations, which is handled in the '''!GenDynamics''' class, found in pcty/client/biomechanicsCommands.py, and add them to the appropriate list
     || updateVariables or stateVariables or rparDynamicVariables ||
   * Once we have all the variables and equations, generate the C code, done via '''generate_c''' method, found in src/csrc/strain_energy/sympy_to_c.py
 * The end result of all of this is that we now have a file: src/csrc/strain_energy/strain_energy.cpp, that has 3 main functions:
   * cpu_advance_be_mech1 - which is the partial update model code based on the AT model (i.e., does not contain the update vars)
   * p_strain_energy - 
   * p_strain_energy_output -


=== GenDynamics ===
 * This class (found in pcty/client/biomechanicsCommands.py), handles getting the variables and equations from the currently submitted Active Tension (AT) model and getting the AT model code ready to be included with the Constitutive model. 
   * Get the currently submitted AT model, and it's variables (as defined from it's meta file)
   * Pass the variables to '''EPSympyGenerator''' class in pcty/client/forms/EPSympyGenerator.py, which creates the header, constants and equations from the variable meta data file, basically turns the meta file into python code.
   * Calls '''rawCompileDynamics''' method from pcty/server/utils/!IonicBuildSympy.c, which removes and then re-creates the dynamicData.pickle file and the helper and update code (i.e., ode_model_model_pert_delta_tweak_cpu_mech.c and odecusingle.so, respectively)

=== rawCompileDynamics_c ===
 * This method will assure that the dynamic model build will start from scratch and be re-initialized to be ready for use, the steps it takes are:
  * It writes out the dynamic model code (which is passed into it) to a local file named: src/ode_cuda/justmodel.py
  * Removes the old version of /src/ode_cuda/ode_model_model_pert_delta_tweak_cpu_mech.c
  * Then does the following: 
    * Runs '''gen_sympy_model.py''' to generate a new dynamicData.pickle file containing dynamic variables (e.g., T_Active), and dynamic state variables (e.g., Lsi and Con).  Reads in the sympy mode code (justmodel.py) and write out the model in C code (model_from_sympy.c).
    * Runs '''buildAndShow.py''' ''--norun --nobuild --dynamics'' to generate a new ode_model_model_pert_delta_tweak_cpu_mech.c file
    * Runs '''builsAndShow.py''' ''--norun'' again, and this time creates odecusingle.so, which will be used for the full update

=== buildAndShow ===
 * Used for CUDA code generation and building of ODE models, there are various command line flags for this program
 * Creates a build_settings.py file which sets the build settings, not surprisingly
 * If the --dynamics flag is supplied when run (and it is for the first time from rawCompileDynamics) it generates code that is a partial update model, without the flag it generates code that is a full update model (e.g., the variable dSL_dt is only found in the full update model)

=== generate_c ===
 * This is the main method used for converting sympy to C code, the steps it takes are:
   * Ensures there is some dynamic code available: src/ode_cuda/ode_model_model_pert_delta_tweak_cpu_mech.c (which is the partial update model generated by buildAndShow).
   * Calls gen_c_helper with list of variables and equations, which will handle changing the sympy code into C code, it calls it once when genOutputs = True and once when genOutputs = False.