diff --git a/doc/img/1_cell.png b/doc/img/1_cell.png
new file mode 100644
index 0000000000000000000000000000000000000000..61eadb7d9b009a5834482afb6b2a38e986c9c944
Binary files /dev/null and b/doc/img/1_cell.png differ
diff --git a/doc/img/1_help.png b/doc/img/1_help.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b3c504ed1b40ee2e0b674ed73f1939db882b1e1
Binary files /dev/null and b/doc/img/1_help.png differ
diff --git a/doc/img/1_invsch.png b/doc/img/1_invsch.png
new file mode 100644
index 0000000000000000000000000000000000000000..49be9bf0357e565276022d196ca78971a566bb67
Binary files /dev/null and b/doc/img/1_invsch.png differ
diff --git a/doc/img/1_invsymb.png b/doc/img/1_invsymb.png
new file mode 100644
index 0000000000000000000000000000000000000000..42eeb04e6d67ecd040b5be9ab224ce96c00136fe
Binary files /dev/null and b/doc/img/1_invsymb.png differ
diff --git a/doc/img/1_invtb.png b/doc/img/1_invtb.png
new file mode 100644
index 0000000000000000000000000000000000000000..7e314d2f299758b5ff527c1e6308856629b5aef5
Binary files /dev/null and b/doc/img/1_invtb.png differ
diff --git a/doc/img/1_libman.png b/doc/img/1_libman.png
new file mode 100644
index 0000000000000000000000000000000000000000..e15e638ad24de9825f7c32d38265042c6ce84947
Binary files /dev/null and b/doc/img/1_libman.png differ
diff --git a/doc/img/1_log.png b/doc/img/1_log.png
new file mode 100644
index 0000000000000000000000000000000000000000..eccb7652a4ad0a3ddb698864ee80c3c7452c145b
Binary files /dev/null and b/doc/img/1_log.png differ
diff --git a/doc/img/1_param.png b/doc/img/1_param.png
new file mode 100644
index 0000000000000000000000000000000000000000..55dfdd195a11aee3b303c74ff5e40121c9a208ad
Binary files /dev/null and b/doc/img/1_param.png differ
diff --git a/doc/img/1_sch.png b/doc/img/1_sch.png
new file mode 100644
index 0000000000000000000000000000000000000000..a74efeeef797fb68cbeea3102996fba17d69d11e
Binary files /dev/null and b/doc/img/1_sch.png differ
diff --git a/doc/img/1_tran.png b/doc/img/1_tran.png
new file mode 100644
index 0000000000000000000000000000000000000000..411e63ea9db26711ee2dc461a974c6f26bd090ff
Binary files /dev/null and b/doc/img/1_tran.png differ
diff --git a/doc/img/2_ade.png b/doc/img/2_ade.png
new file mode 100644
index 0000000000000000000000000000000000000000..3c436000e2caf4d0474e35ef442227c008253fca
Binary files /dev/null and b/doc/img/2_ade.png differ
diff --git a/doc/img/2_configadel.png b/doc/img/2_configadel.png
new file mode 100644
index 0000000000000000000000000000000000000000..280a0e9c8654cea9ed0d91cf19e304924e0219bc
Binary files /dev/null and b/doc/img/2_configadel.png differ
diff --git a/doc/img/2_configfinal.png b/doc/img/2_configfinal.png
new file mode 100644
index 0000000000000000000000000000000000000000..17e092634bff09348288f8d5bc9aa73055a74ba0
Binary files /dev/null and b/doc/img/2_configfinal.png differ
diff --git a/doc/img/2_configparam.png b/doc/img/2_configparam.png
new file mode 100644
index 0000000000000000000000000000000000000000..79421e9d9d6f63412621e8dc2ed8f78912140ee1
Binary files /dev/null and b/doc/img/2_configparam.png differ
diff --git a/doc/img/2_configview.png b/doc/img/2_configview.png
new file mode 100644
index 0000000000000000000000000000000000000000..f6e7160a698375dbe6c44240ff5d2a205a1ee2d2
Binary files /dev/null and b/doc/img/2_configview.png differ
diff --git a/doc/img/2_display.png b/doc/img/2_display.png
new file mode 100644
index 0000000000000000000000000000000000000000..b004575339d52d9ad2dc623d58ec106ce4c20a8a
Binary files /dev/null and b/doc/img/2_display.png differ
diff --git a/doc/img/2_drc-result.png b/doc/img/2_drc-result.png
new file mode 100644
index 0000000000000000000000000000000000000000..72ca0cfcd128d7f44579b9ffb244c069a17c3c79
Binary files /dev/null and b/doc/img/2_drc-result.png differ
diff --git a/doc/img/2_drc-setup.png b/doc/img/2_drc-setup.png
new file mode 100644
index 0000000000000000000000000000000000000000..a4e8ff8b55fb6647205f20ff6f45e060e03c0717
Binary files /dev/null and b/doc/img/2_drc-setup.png differ
diff --git a/doc/img/2_drcdata.png b/doc/img/2_drcdata.png
new file mode 100644
index 0000000000000000000000000000000000000000..24cff1ce1cf023ebe8e54ad775df9b48e85a14a4
Binary files /dev/null and b/doc/img/2_drcdata.png differ
diff --git a/doc/img/2_drcdebug.png b/doc/img/2_drcdebug.png
new file mode 100644
index 0000000000000000000000000000000000000000..44bdf33cb55c6d3007c1ff24945245f7ba7e79dc
Binary files /dev/null and b/doc/img/2_drcdebug.png differ
diff --git a/doc/img/2_drcrules.png b/doc/img/2_drcrules.png
new file mode 100644
index 0000000000000000000000000000000000000000..9eaf98913c340c7d31cd2b69e0dd4a2a1de6d7db
Binary files /dev/null and b/doc/img/2_drcrules.png differ
diff --git a/doc/img/2_invlayout.png b/doc/img/2_invlayout.png
new file mode 100644
index 0000000000000000000000000000000000000000..4a40b457299c5a85851fa2fea749b4256f462b40
Binary files /dev/null and b/doc/img/2_invlayout.png differ
diff --git a/doc/img/2_laygen1.png b/doc/img/2_laygen1.png
new file mode 100644
index 0000000000000000000000000000000000000000..5c0c982215841d6791a3decd3b0ddb8ec6f56772
Binary files /dev/null and b/doc/img/2_laygen1.png differ
diff --git a/doc/img/2_laygen2.png b/doc/img/2_laygen2.png
new file mode 100644
index 0000000000000000000000000000000000000000..6e0fdf3da46eb40fe3cfaefa0399f966dd84403b
Binary files /dev/null and b/doc/img/2_laygen2.png differ
diff --git a/doc/img/2_layxl.png b/doc/img/2_layxl.png
new file mode 100644
index 0000000000000000000000000000000000000000..c5392427dfcd6f371ba79b540aedd2ea20579405
Binary files /dev/null and b/doc/img/2_layxl.png differ
diff --git a/doc/img/2_layxl2.png b/doc/img/2_layxl2.png
new file mode 100644
index 0000000000000000000000000000000000000000..3a5ad5f8fbab10fee324d34705cc822e6ed04859
Binary files /dev/null and b/doc/img/2_layxl2.png differ
diff --git a/doc/img/2_lvsdata.png b/doc/img/2_lvsdata.png
new file mode 100644
index 0000000000000000000000000000000000000000..6e9b152057affc1a0ec60e781a1373634896f8cb
Binary files /dev/null and b/doc/img/2_lvsdata.png differ
diff --git a/doc/img/2_lvsdebug.png b/doc/img/2_lvsdebug.png
new file mode 100644
index 0000000000000000000000000000000000000000..3684cc012535a1466ec91237419e742f3d4b07d9
Binary files /dev/null and b/doc/img/2_lvsdebug.png differ
diff --git a/doc/img/2_lvsoutput.png b/doc/img/2_lvsoutput.png
new file mode 100644
index 0000000000000000000000000000000000000000..9661e0464daf1e15e045e02e11fedecc86217452
Binary files /dev/null and b/doc/img/2_lvsoutput.png differ
diff --git a/doc/img/2_lvsrules.png b/doc/img/2_lvsrules.png
new file mode 100644
index 0000000000000000000000000000000000000000..e78b4a62d0e02460e23426aa6a8c758f0ce66605
Binary files /dev/null and b/doc/img/2_lvsrules.png differ
diff --git a/doc/img/2_newlib.png b/doc/img/2_newlib.png
new file mode 100644
index 0000000000000000000000000000000000000000..e24523c7da77b837a1735df6daf16c19c2108323
Binary files /dev/null and b/doc/img/2_newlib.png differ
diff --git a/doc/img/2_qrcextract.png b/doc/img/2_qrcextract.png
new file mode 100644
index 0000000000000000000000000000000000000000..d899316994cba5f411249ce7692d607acff77c64
Binary files /dev/null and b/doc/img/2_qrcextract.png differ
diff --git a/doc/img/2_qrcextracted.png b/doc/img/2_qrcextracted.png
new file mode 100644
index 0000000000000000000000000000000000000000..d3b9c22c44c903bfd72fad9cc08f31586f907716
Binary files /dev/null and b/doc/img/2_qrcextracted.png differ
diff --git a/doc/img/2_qrcinit.png b/doc/img/2_qrcinit.png
new file mode 100644
index 0000000000000000000000000000000000000000..a6052eed8447dd24e28ff26289d0630bce0f75bd
Binary files /dev/null and b/doc/img/2_qrcinit.png differ
diff --git a/doc/img/2_qrcnetlist.png b/doc/img/2_qrcnetlist.png
new file mode 100644
index 0000000000000000000000000000000000000000..03f7be1d1cfadd8ed32767addcccbc93e3548b13
Binary files /dev/null and b/doc/img/2_qrcnetlist.png differ
diff --git a/doc/img/2_qrcsetup.png b/doc/img/2_qrcsetup.png
new file mode 100644
index 0000000000000000000000000000000000000000..06efb9fd57b0373483d388453f5095045ebcbd26
Binary files /dev/null and b/doc/img/2_qrcsetup.png differ
diff --git a/doc/img/2_saveade.png b/doc/img/2_saveade.png
new file mode 100644
index 0000000000000000000000000000000000000000..eb6ae8ed8dbf6fab21e2fece64af814a6c2a0126
Binary files /dev/null and b/doc/img/2_saveade.png differ
diff --git a/doc/img/2_simupara.png b/doc/img/2_simupara.png
new file mode 100644
index 0000000000000000000000000000000000000000..ba2fb1a7fb7c80e30267243f3f7f37efa08b097a
Binary files /dev/null and b/doc/img/2_simupara.png differ
diff --git a/doc/img/2_template.png b/doc/img/2_template.png
new file mode 100644
index 0000000000000000000000000000000000000000..b5ae1038b6881fbfbd9abc4e462b931606930524
Binary files /dev/null and b/doc/img/2_template.png differ
diff --git a/doc/img/3_adel.png b/doc/img/3_adel.png
new file mode 100644
index 0000000000000000000000000000000000000000..219e0a283e685a97a530a902577e293d52ced52d
Binary files /dev/null and b/doc/img/3_adel.png differ
diff --git a/doc/img/3_anncomponent.png b/doc/img/3_anncomponent.png
new file mode 100644
index 0000000000000000000000000000000000000000..7937939344b7c6c91abaf2b8e8933178af509fc7
Binary files /dev/null and b/doc/img/3_anncomponent.png differ
diff --git a/doc/img/3_annextractedcomponent.png b/doc/img/3_annextractedcomponent.png
new file mode 100644
index 0000000000000000000000000000000000000000..f1b805f5d9e8c005059b7935eb6aa4ed2926ec71
Binary files /dev/null and b/doc/img/3_annextractedcomponent.png differ
diff --git a/doc/img/3_annextractedoppoint.png b/doc/img/3_annextractedoppoint.png
new file mode 100644
index 0000000000000000000000000000000000000000..cefdab0f4dfd0e7dcedeeae870157fcb0f4040b3
Binary files /dev/null and b/doc/img/3_annextractedoppoint.png differ
diff --git a/doc/img/3_annoppoint.png b/doc/img/3_annoppoint.png
new file mode 100644
index 0000000000000000000000000000000000000000..963cacb4dc7e86c3d3e2ead414a015f801f70ca7
Binary files /dev/null and b/doc/img/3_annoppoint.png differ
diff --git a/doc/img/3_annotatesetup.png b/doc/img/3_annotatesetup.png
new file mode 100644
index 0000000000000000000000000000000000000000..cb6cb4b92c032eb6f27217e758957e6e703215e4
Binary files /dev/null and b/doc/img/3_annotatesetup.png differ
diff --git a/doc/img/3_bodeoutput.png b/doc/img/3_bodeoutput.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf73cb3cd4740858a283a298e51e289e25e55361
Binary files /dev/null and b/doc/img/3_bodeoutput.png differ
diff --git a/doc/img/3_bodeoutputsetup.png b/doc/img/3_bodeoutputsetup.png
new file mode 100644
index 0000000000000000000000000000000000000000..c36aa1bf33e85737c7599d4ebbd848130798784d
Binary files /dev/null and b/doc/img/3_bodeoutputsetup.png differ
diff --git a/doc/img/3_cdnshelp.png b/doc/img/3_cdnshelp.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b3c504ed1b40ee2e0b674ed73f1939db882b1e1
Binary files /dev/null and b/doc/img/3_cdnshelp.png differ
diff --git a/doc/img/3_dc.png b/doc/img/3_dc.png
new file mode 100644
index 0000000000000000000000000000000000000000..66059f1f1137f815a78b35265ad36e9ef3410201
Binary files /dev/null and b/doc/img/3_dc.png differ
diff --git a/doc/img/3_dczonesat.png b/doc/img/3_dczonesat.png
new file mode 100644
index 0000000000000000000000000000000000000000..c33dd3c91244091ba81e8cbf899a734cbd770c89
Binary files /dev/null and b/doc/img/3_dczonesat.png differ
diff --git a/doc/img/3_noiseinputreferred.png b/doc/img/3_noiseinputreferred.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b6c6e8c6f6db22e2d3cdea2d436da89023f73e2
Binary files /dev/null and b/doc/img/3_noiseinputreferred.png differ
diff --git a/doc/img/3_noiseinputreferredstable.png b/doc/img/3_noiseinputreferredstable.png
new file mode 100644
index 0000000000000000000000000000000000000000..a96b3550ba56ba00437d3d5623bd84117cf53d9d
Binary files /dev/null and b/doc/img/3_noiseinputreferredstable.png differ
diff --git a/doc/img/3_noiseoutputreferred.png b/doc/img/3_noiseoutputreferred.png
new file mode 100644
index 0000000000000000000000000000000000000000..f91d98778799ebfeee13bcc87bfe503eba3d06b6
Binary files /dev/null and b/doc/img/3_noiseoutputreferred.png differ
diff --git a/doc/img/3_noiseportsetup.png b/doc/img/3_noiseportsetup.png
new file mode 100644
index 0000000000000000000000000000000000000000..191918bb823ebaee8050150e6f8e24b4969cafc3
Binary files /dev/null and b/doc/img/3_noiseportsetup.png differ
diff --git a/doc/img/3_noiseschematic.png b/doc/img/3_noiseschematic.png
new file mode 100644
index 0000000000000000000000000000000000000000..18025b39d5729f5338aa9d7a982ff277212aa91a
Binary files /dev/null and b/doc/img/3_noiseschematic.png differ
diff --git a/doc/img/3_noisesimconfig.png b/doc/img/3_noisesimconfig.png
new file mode 100644
index 0000000000000000000000000000000000000000..080aa96299c997cb48dfe0d1e53a8e110f885389
Binary files /dev/null and b/doc/img/3_noisesimconfig.png differ
diff --git a/doc/img/3_oppointsave.png b/doc/img/3_oppointsave.png
new file mode 100644
index 0000000000000000000000000000000000000000..82d5db28ab0d5dc6fc3090e43d4297da78c40f22
Binary files /dev/null and b/doc/img/3_oppointsave.png differ
diff --git a/doc/img/3_oppointselectparam.png b/doc/img/3_oppointselectparam.png
new file mode 100644
index 0000000000000000000000000000000000000000..13610e196f1fe4ee887a1828e897c6c0da47a458
Binary files /dev/null and b/doc/img/3_oppointselectparam.png differ
diff --git a/doc/img/3_oppointsimu.png b/doc/img/3_oppointsimu.png
new file mode 100644
index 0000000000000000000000000000000000000000..d0e9380b92079a5fa5357128d47e6acecbf3605a
Binary files /dev/null and b/doc/img/3_oppointsimu.png differ
diff --git a/doc/img/3_powercalc.png b/doc/img/3_powercalc.png
new file mode 100644
index 0000000000000000000000000000000000000000..686c27c7ab0c3d15084359a0fa9c47b11c1e7c0a
Binary files /dev/null and b/doc/img/3_powercalc.png differ
diff --git a/doc/img/3_powerresult.png b/doc/img/3_powerresult.png
new file mode 100644
index 0000000000000000000000000000000000000000..cf715297233ccfb2275c71cf60c92f82dbbb4f3e
Binary files /dev/null and b/doc/img/3_powerresult.png differ
diff --git a/doc/img/3_printoppoint.png b/doc/img/3_printoppoint.png
new file mode 100644
index 0000000000000000000000000000000000000000..a097c5018b96e624bbc8bff6cdfc39b59d76e7f3
Binary files /dev/null and b/doc/img/3_printoppoint.png differ
diff --git a/doc/img/3_resultbrowser.png b/doc/img/3_resultbrowser.png
new file mode 100644
index 0000000000000000000000000000000000000000..c49aaba4b525066ac9620accae820a4f1b4c78b6
Binary files /dev/null and b/doc/img/3_resultbrowser.png differ
diff --git a/doc/img/3_resultbrowseraddsignal.png b/doc/img/3_resultbrowseraddsignal.png
new file mode 100644
index 0000000000000000000000000000000000000000..5b0192658bc4bc166e2f32bde5d662620f9abf92
Binary files /dev/null and b/doc/img/3_resultbrowseraddsignal.png differ
diff --git a/doc/img/3_saveall.png b/doc/img/3_saveall.png
new file mode 100644
index 0000000000000000000000000000000000000000..4f684e424391f8a921fbc26579cdd6f68bdf68d1
Binary files /dev/null and b/doc/img/3_saveall.png differ
diff --git a/doc/img/3_tran.png b/doc/img/3_tran.png
new file mode 100644
index 0000000000000000000000000000000000000000..411e63ea9db26711ee2dc461a974c6f26bd090ff
Binary files /dev/null and b/doc/img/3_tran.png differ
diff --git a/doc/sync.py b/doc/sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..949097394f1f31f5291b43e2f22684522fbc463a
--- /dev/null
+++ b/doc/sync.py
@@ -0,0 +1,49 @@
+#!/usr/bin/python3
+#-----------------------------------------------------------------------------
+# Project    : Tutoriels - Conception de circuits intégrés analogiques
+#-----------------------------------------------------------------------------
+# File       : sync.py
+# Authors    : Mickael Fiorentino <mickael.fiorentino@polymtl.ca>
+# Lab        : GRM - Polytechnique Montréal
+# Date       : <2019-07-24 Wed>
+#-----------------------------------------------------------------------------
+# Description: Synchronisation de la documentation sur le Wiki du GRM
+#              - Interface à partir de l'API XML-RPC de DokuWiki
+#              --> module dokuwiki: https://python-dokuwiki.readthedocs.io
+#-----------------------------------------------------------------------------
+import dokuwiki
+import argparse
+
+# Arguments
+parser = argparse.ArgumentParser()
+parser.add_argument("login", type=str, help="Nom d'utilisateur sur le Wiki du GRM")
+parser.add_argument("passwd", type=str, help="Mot de passe sur le Wiki du GRM")
+args = parser.parse_args()
+
+# Parameters
+username  = args.login
+password  = args.passwd
+wiki_url  = 'https://intranet.grm.polymtl.ca/wiki'
+namespace = ':tutos:inverseur:'
+img_dir   = 'img'
+wiki_dir  = 'wiki'
+
+# Login                                                   
+try:
+    wiki = dokuwiki.DokuWiki(wiki_url, username, password, cookieAuth=True)
+except (DokuWikiError, Exception) as err:
+    print('unable to connect: %s' % err)
+
+# Backup pages 
+pages_list = wiki.pages.list(namespace)
+for p in pages_list:
+    page = wiki.pages.get(p['id'])
+    name = wiki_dir + '/' + p['id'].split(':')[-1] + '.dwiki'
+    with open(name, 'w') as f:
+        f.write(page)
+
+# Backup Media
+media_list = wiki.medias.list(namespace)
+for m in media_list:
+    name = m['id'].split(':')[-1]
+    wiki.medias.get(m['id'], dirpath=img_dir, filename=name, overwrite=True)
diff --git a/doc/wiki/1_schema.dwiki b/doc/wiki/1_schema.dwiki
new file mode 100644
index 0000000000000000000000000000000000000000..4155832406b03a25afbc71f3bd4e0f47828fa75c
--- /dev/null
+++ b/doc/wiki/1_schema.dwiki
@@ -0,0 +1,198 @@
+
+====== Conception & simulation des circuits analogiques ======
+
+— //[[mickael.fiorentino@polymtl.ca|Mickael Fiorentino]] 2019/07/20// ; //[[erika.miller-jolicoeur@polymtl.ca|Erika Miller-Jolicoeur]] 2019/07/20// —
+
+La conception d'un circuit intégré analogique CMOS passe par deux étapes complémentaires: la **conception du schéma**, qui permet de dimensionner le circuit en accord avec les performances définies au cahier des charges, et l'**édition du dessin des masques**, qui permet d'agencer les transistors et leurs interconnexions au niveau physique. Un circuit intégré est réalisé à partir d'un procédé de fabrication mis au point par un //fondeur//, tel que TSMC, Intel ou STMicroelectronics. Le procédé de fabrication est abstrait par un ensemble de //règles de dessin//, telles que la largeur minimale des interconnexions ou la largeur minimale des transistors, qui garantissent au concepteur que son circuit sera fonctionnel si elles sont respectées. Les outils de conception assistée par ordinateur (//Computer Aided Design (CAD) tools//) sont une interface entre les abstractions du procédé et les concepteurs de circuits intégrés. L’intégration de milliards de transistors dans un circuit intégré réalisant une fonction complexe ne serait pas réalisable sans eux. Plusieurs étapes de vérification sont nécessaires avant la mise en production d'un circuit intégré. Dans un premier temps, la simulation fonctionnelle du schéma permet de dimensionner les transistors de sorte que le circuit atteigne les performances désirées. Ensuite, le dessin des masques est validé par vérification des règles de dessin (//Design Rules Check (DRC)//). Enfin, après extraction de son modèle électrique, la simulation post-implémentation du dessin des masques permet de vérifier que le circuit se comporte toujours tel que prévu lorsqu’on prend en compte les effets parasites (capacités parasites, effet d’antenne, etc).
+
+Dans le cadre de ces tutoriels nous utiliserons l’environnement de simulation et d’édition de dessin des masques **Virtuoso** de //Cadence// à travers la conception d’un inverseur CMOS. Nous utiliserons le kit de développement ''GPDK45'' (//Generic Process Design Kit - 45nm//) de //Cadence//. 
+
+Cette première partie du tutoriel traite de la conception et de la simulation du schéma de l'inverseur. Le répertoire de travail associé à ce tutoriel se situe à l’emplacement ''~/Tutos/inverseur''.
+
+===== Environnement de travail =====
+
+//Virtuoso// s’exécute sur les postes de travail Linux dans un environnement ''tcsh''. Il est préférable de lancer //Virtuoso// à partir de votre répertoire de travail. Pour les outils de //Cadence//, deux fichiers de configurations sont en général nécessaires:
+
+  * ''setup.csh'': Script qui défini les chemins des exécutables et la hiérarchie du projet.
+  * ''cds.lib'': Fichier de configuration qui défini les emplacements des librairies de travail.
+
+
+==== Démarrer l’outil ====
+
+  * Se placer a la racine du projet et configurer l'environnement
+
+<code:bash>
+[shell]% cd ~/Tutos/inverseur/
+[shell]% source setup.csh
+</code>
+
+  * Démarrer //Virtuoso//
+
+<code:bash>
+[shell]% virtuoso &
+</code>
+
+Après avoir exécuté ces commandes, vous allez voir apparaitre la fenêtre de contrôle de //Virtuoso//, appelée //Command Interpreter Window// (CIW) tel qu’illustré à la <imgref fig:log>. Elle contient l’historique de toutes les opérations que vous réaliserez, ainsi qu’un menu à partir duquel vous pouvez lancer les différents outils de //Virtuoso//.
+
+<imgcaption fig:log| Fenêtre de contrôle de Virtuoso (CIW)>
+{{1_log.png|Fenêtre de contrôle de Virtuoso (CIW)}}
+</imgcaption>
+
+L’accès aux circuits réalisés dans //Virtuoso// est géré par le //gestionnaire de librairies//, tel qu’illustré à la <imgref fig:libman>. Il contient des librairies standards (''analogLib'', ''basic''), des librairies spécifiques au kit (''gpdk045'', ''gpdk045_tech''), ainsi que des libraires créées par l’utilisateur (''ele8304''). Une librairie contient un ensemble de circuits appelés //cellules//. Chaque cellule est décrite par différentes représentations (//schematic, layout, symbol//, etc.).
+
+<imgcaption fig:libman| Gestionnaire de librairies>
+{{1_libman.png|Gestionnaire de librairies}}
+</imgcaption>
+
+Pour lancer le gestionnaire de librairie à partir de la fenêtre de contrôle de //Virtuoso// sélectionnez: ''Tools -> Library Manager''. Pour créer la librairie de travail de ce laboratoire sélectionnez: ''File -> New -> Library'', appelez là: ''ele8304'', puis sélectionnez: ''attach to an existing technology library'', et sélectionnez la technologie: ''gsclib045_tech''.
+
+==== Obtenir de l’aide ====
+
+En complément de ce guide vous avez également accès à l’intégralité de la documentation de //Virtuoso// directement dans l’aide //Cadence//. Pour lancer l’aide sélectionnez: ''Help -> User Guide''. Vous obtiendrez une fenêtre similaire à la <imgref fig:cdnshelp>. Vous pouvez parcourir les différents dossier en sélectionnant ''View -> Show Navigation''.
+
+<imgcaption fig:cdnshelp| Documentation de Virtuoso>
+{{1_help.png|Documentation de Virtuoso}}
+</imgcaption>
+
+===== Édition du schéma =====
+
+<imgcaption fig:cell| Nouvelle cellule>
+{{1_cell.png|Nouvelle cellule}}
+</imgcaption>
+
+Dans cette partie nous allons nous intéresser à la conception et à la simulation du schéma de l’inverseur. Pour ce faire nous allons commencer par créer une cellule: Positionnez-vous dans la librairie ''ele8304'', puis sélectionnez: ''File -> New -> Cell View'', et appelez là ''INV''. Assurez-vous que la vue ''schematic'' est bien sélectionnée, et que l’outil ''schematic L'' sera utilisé pour l’édition du schéma, comme le montre la <imgref fig:cell>.
+
+Pour plus de clarté, on vous suggère d’organiser votre espace de travail, composé du CIW, du gestionnaire de librairies, et de l’éditeur de schéma, comme le montre la <imgref fig:sch>.
+
+<imgcaption fig:sch| Éditeur de schéma>
+{{1_sch.png|Éditeur de schéma}}
+</imgcaption>
+
+==== Raccourcis claviers ====
+
+L’éditeur de schéma de //Virtuoso// s’utilise principalement à partir des raccourcis claviers décrits dans le tableau ci-dessous. Le principe est le suivant: Chaque touche (raccourcis) utilisée modifie le **mode** dans lequel l’éditeur se trouve. Par exemple en mode ''m'' (//move//), chaque fois que vous sélectionnez un élément, vous appliquerez la commande //move// sur celui-ci. Pour sortir d’un mode il faut utiliser la touche ''ESC'' (//echap//). D’autre part, vous n’avez pas besoin de maintenir le clic sur un élément pour y appliquer une action: cliquez une fois pour activer l’action associée au mode, et une deuxième fois pour l’appliquer.
+
+^**Raccourci**  ^ **Description**                                                                    ^
+|''ESC''        |//Echap//: Sortir d’un mode                                                        |
+|''f''          |//Focus//: Visualiser l’ensemble du schéma                                         |
+|''z''          |//Zoom//: Zoomer sur la zone sélectionnée. ''Shift-Z'' (zoom), ''Ctrl-Z'' (dézoom) |
+|''q''          |//Properties//: Éditer les propriétés des objets                                   |
+|''i''          |//Instanciate//: Instancier des éléments du gestionnaire de librairie              |
+|''w''          |//Wire//: Créer des liaisons entres les objets                                     |
+|''p''          |//Pins//: Instancier les pins d’entrées/sorties                                    |
+
+==== Schéma ====
+
+<imgcaption fig:invsch| Schéma de l'inverseur>
+{{1_invsch.png|Schéma de l'inverseur}}
+</imgcaption>
+
+Dans cette partie nous allons créer le schéma de l’inverseur. Pour commencer, vous devez instancier deux transistors (//nmos// et //pmos//). Utilisez la touche ''i'' dans l’éditeur de schémas et sélectionnez ''pmos1v'' puis ''nmos1v'' dans la librairie ''gpdk045''.
+
+Utilisez la touche ''w'' pour créer les connexions entre les transistors de façon à obtenir le schéma d’un inverseur. N’oubliez-pas de connecter les //bulk// du //nmos// et du //pmos// à leur source. Ensuite, utilisez la touche ''p'' pour ajouter des pins d’entrées/sorties. Vous devrez ajouter une pin d’entrée ''in'' (//input//), une pin de sortie ''out'' (//output//), une pin pour l’alimentation ''vdd'' (//inputoutput//) et une pin ''vss'' (//inputoutput//) pour la masse.
+
+Vous devriez obtenir le schéma de la <imgref fig:invsch>. Pour valider votre schéma cliquez sur ''Check and Save'' en haut à gauche.
+
+==== Symbole ====
+
+<imgcaption fig:invsymb| Symbole de l'inverseur>
+{{1_invsymb.png|Symbole de l'inverseur}}
+</imgcaption>
+
+Pour pouvoir intégrer cet inverseur dans un banc d’essai, nous allons créer un symbole associé au schéma. À terme nous aurons donc trois vues différentes de l’inverseur: //schematic//, //symbol//, et //layout//. Sélectionnez: ''Create -> Cellview -> From Cellview''. Après avoir choisi la position des pins sur le symbole, vous pouvez choisir de garder son apparence par défaut, ou vous pouvez choisir de la modifier, tel que le montre la <imgref fig:invsymb>. Les seuls éléments que vous ne devez pas supprimer sont les pins.
+
+===== Simulations du schéma =====
+
+Dans cette partie nous allons nous intéresser à la simulation fonctionnelle de l’inverseur à partir de son symbole. Nous aborderons deux aspects:
+
+  - //Le banc d’essai//: Il s’agit d’un circuit permettant de générer les stimuli nécessaires à l’obtention des courbes caractéristiques de l’inverseur.
+  - //L’environnement de simulation//: Il s’agit d’un ensemble d’outils permettant d’évaluer le comportement d’un circuit à partir de son modèle électrique.
+
+==== Banc d’essai ====
+
+Pour créer le banc d’essai de l’inverseur, placez-vous dans la librairie ''ele8304'', créez une nouvelle cellule: ''File -> New -> Cellview'', et nommez là ''INV_TB''. Une nouvelle fenêtre s’ouvre dans laquelle vous pouvez instancier tous les composants du banc d’essai, comme le montre la <imgref fig:invtb>. Les composants utiles à la réalisation du banc d’essai sont listés dans le tableau ci-dessous. Utilisez la touche ''l'' pour apposer un label sur les fils. Faites-le pour les signaux d’entrées et de sorties (''vin'' et ''vout'') comme le montre la <imgref fig:invtb>.
+
+^**Instance** ^**Librairie**  ^**Vue** ^**Description**                                                ^
+|''INV''      |ele8304        |symbol  |DUT: //Device Under Test//                                     |
+|''vdc''      |analogLib      |symbol  |Alimentation fixe de $1V$                                      |
+|''vpulse''   |analogLib      |symbol  |Signal périodique rectangulaire: $V1=0V$, $V2=1V$, $T=1\mu s$  |
+|''gnd''      |analogLib      |symbol  |Masse du circuit                                               |
+|''cap''      |analogLib      |symbol  |Capacité de sortie (charge) du circuit: $C=10pf$               |
+
+<imgcaption fig:invtb| Banc d’essai de l’inverseur>
+{{1_invtb.png|Banc d’essai de l’inverseur}}
+</imgcaption>
+
+==== Configuration ====
+
+Pour démarrer l’environnement de simulation à partir de l’éditeur schéma, sélectionnez: ''Launch -> ADE L''. Par défaut, les simulations s’exécutent dans votre dossier //home//, mais comme ce répertoire se situe sur le réseau le temps d’accès aux fichiers est plus long, ce qui ralenti les simulations. D’autre part, les fichiers générés par les simulations peuvent être de taille importante. Nous allons donc créer un dossier pour les simulations sur les machines locales:
+
+<code:bash>
+[shell]% mkdir -p /export/tmp/<user>/simulations
+</code>
+
+Dans la fenêtre ''ADE L'', sélectionnez: ''Setup -> Simulator/Directory/Host''. Assurez vous de sélectionner le simulateur ''spectre'', et de pointer le répertoire sur: ''/export/tmp/<user>/simulations''.
+
+Afin que cette configuration devienne celle par défaut, et ainsi éviter d’avoir à la modifier pour chacune des simulations, nous allons éditer deux fichiers que //Virtuoso// utilise pour configurer le comportement des différents outils au démarrage:
+
+  * Les fichiers ''.cdsinit'' sont utilisés pour lancer des scripts de configuration.
+  * Les fichiers ''.cdsenv'' sont utilisés pour configurer toutes les options de l’environnement. 
+
+Les fichiers ''.cdsenv'' sont chargés en premier, leur configuration peut donc être écrasée par celle des fichiers ''.cdsinit''. //Virtuoso// lit les fichiers ''.cdsenv'' dans l’ordre présenté dans le tableau ci-dessous (le fichier le plus bas a la priorité la plus élevée)
+
+^**Niveau**                       ^**Chemin**                                                     ^
+|Par défaut (pour chaque outils)  |''/CMC/tools/cadence/<IC_dir>/tools/dfII/etc/<tool>/.cdsenv''  |
+|Tous les utilisateurs            |''/CMC/tools/cadence/<IC_dir>/tools/dfII/local/.cdsenv''       |
+|Mon utilisateur                  |''~/.cdsenv''                                                  |
+|Ce projet                        |''<Project_dir>/.cdsenv''                                      |
+
+Pour configurer le chemin par défaut du répertoire de simulation il faut éditer le fichier ''.cdsenv'' du répertoire ''~/Labs/Tuto/inverseur''. Décommentez la ligne suivante, et remplacez le chemin par celui du répertoire créé précédemment
+
+<code>
+asimenv.startup  projectDir string  "/export/tmp/<user>/simulations"
+</code>
+
+Le comportement de //Virtuoso// est légèrement différent lors du chargement du fichier ''.cdsinit''. //Virtuoso// parcours d’abord le répertoire du projet, puis le répertoire //home//, et s’arrête dès que le premier fichier est trouvé. À titre d’exemple, nous allons configurer le fichier ''.cdsinit'' pour qu’il lance automatiquement le gestionnaire de librairie au démarrage de //Virtuoso//. Notez que toutes ces modifications n’entreront en vigueur qu’au prochain démarrage de //Virtuoso//.
+
+<code>
+when ( isFile("./cds.lib")
+       printf("\nFYI: Launched library manager.")
+       ddsOpenLibManager()
+     )
+</code>
+
+==== Simulation transitoire ====
+
+La simulation transitoire permet d’évaluer le comportement dynamique d’un circuit lorsqu’il est soumis à un ensemble de stimuli, comme c’est le cas par exemple de l’inverseur lorsqu’il est soumis aux stimuli du signal rectangulaire périodique généré par l’alimentation ''vpulse''.
+
+Pour configurer le type de simulation à effectuer, sélectionnez ''Analyses -> Choose'', puis choisissez: ''Analysis -> tran'', et: ''Stop Time -> 4u'' pour définir le temps de simulation (ce qui correspond à 4 périodes du signal périodique rectangulaire ''vpulse''). Enfin, sélectionnez: ''Accuracy -> moderate''.
+
+Pour sélectionner les signaux à observer, sélectionnez: ''outputs -> to be plotted -> select on design'', et sélectionnez les signaux ''vin'' et ''vout'' du banc d’essai. Finalement, pour lancer la simulation cliquez sur le bouton vert. Vous devriez obtenir un résultat similaire au chronogramme de la <imgref fig:tran>. Notez que pour séparer les courbes vous devez sélectionner: ''Graph -> Split All Strips''.
+
+La <imgref fig:tran> montre que la réponse de l’inverseur à un signal périodique n’est pas parfaite. D’une part on observe une réponse $RC$ importante, qui est principalement due à la capacité de sortie du banc d’essai (observez la différence pour $C = 1pf$). D’autre part, le temps de montée est différent du temps de descente. Ceci est dû au fait que l’inverseur n’est pas balancé. À dimensions égales, le courant qui traverse le //nmos// est plus important que le courant qui traverse le //pmos// (mobilité des électrons //vs// mobilité des trous).
+
+<imgcaption fig:tran| Simulation transitoire>
+{{1_tran.png|Simulation transitoire}}
+</imgcaption>  
+
+==== Simulation statique paramétrique ====
+
+Le but de la simulation statique paramétrique est de déterminer les rapports $\frac{W}{L}$ des transistors de façon à ce que leurs points de fonctionnement satisfassent au cahier des charges. En règle générale, on ne modifie jamais la longueur $L$ des transistors, qui restent à leurs tailles minimales (45nm ici). Dans le cas de l’inverseur, le but est de déterminer la largeur $W_p$ du //pmos// telle que l’inverseur soit balancé, c’est à dire que sa sortie vaille $VDD / 2$ lorsque son entrée vaut $VDD / 2$. Une approche analytique (résolution approximative des équations) peut être utilisée en complément des simulations. Les résultats analytiques peuvent cibler le(s) transistor(s) à modifier, et donner un ordre de grandeur de la valeur à utiliser. Les simulations, qui utilisent des modèles plus élaborés, permettent de resserrer l’espace des solutions et d’obtenir des valeurs plus précises. Ici, nous allons simuler le comportement de l’inverseur lorsqu’il est soumis à une rampe de tension de $0 V$ à $1 V$ (simulation statique), le tout pour plusieurs valeurs de $W_p$ (simulation paramétrique).
+
+=== Simulation statique ===
+
+Supprimez d’abord la simulation transitoire, puis sélectionnez: ''Analyses -> Choose -> Analysis -> dc''. Puis, sélectionnez: ''Sweep Variable -> Component Parameter'', puis: ''Select Component'', et choisissez ''vpulse'' sur le banc d’essai. Sélectionnez: ''Parameter Name -> dc''. Enfin, configurez la rampe de tension avec: ''Sweep Range -> start: 0, stop: 1''.
+
+=== Simulation paramétrique ===
+
+Dans un premier temps il faut créer la variable ''wp'' qui servira de paramètre variable à la largeur du transistor //pmos//. Pour cela, sélectionnez l’inverseur dans le banc d’essai et utilisez la combinaison de touche ''shift+e'' pour descendre d’un niveau dans la hiérarchie (cela vous conduira au schéma de l’inverseur). Sélectionnez le //pmos// et utilisez la touche ''q'' pour modifier ses paramètres. Inscrivez: ''Total Width -> wp'' à la place de la valeur par défaut. Sauvegardez (''Check and Save''), puis revenez au banc d’essai avec la combinaison de touche ''ctrl+e''. Pour importer la variable créée dans l’environnement de simulation ''ADE L'' sélectionnez: ''Variables -> Copy From Cellview''. Vous devriez voir ''wp'' apparaitre dans le panneau latéral. Pour réaliser la simulation statique paramétrique, sélectionnez: ''Tools -> Parametric Analysis''. Puis sélectionnez la variable ''wp'' et faites là varier: ''From: 120n – To: 300n'', avec: ''Step Mode -> Linear Steps'', et: ''Step Size -> 20n''. Enfin, sélectionnez: ''Analysis -> Start'' pour visualiser la réponse de l’inverseur à l’échelon de tension pour 10 valeurs de ''wp'' différentes.
+
+La <imgref fig:param> montre que $W_p = 140nm$ correspond au point de fonctionnement pour lequel l’inverseur est le plus balancé. Vous pouvez donc remplacer: ''wp -> 140n'' dans les propriétés du transistor //pmos// pour la suite.
+
+<imgcaption fig:param| Simulation paramétrique>
+{{1_param.png|Simulation paramétrique}}
+</imgcaption>
+
+==== Sauvegarder l’environnement de simulation ====
+
+Afin de conserver les résultats et la configuration de la simulation, vous pouvez sauvegarder l’état de l’environnement de simulation en suivant ''Session -> Save state''. Sélectionnez: ''Save state option -> Cellview'' et donnez un nom à votre configuration. Remarquez qu’une vue s’est ajoutée dans le gestionnaire de librairie, et peut donc maintenant être directement accédée de cet endroit.
diff --git a/doc/wiki/2_layout.dwiki b/doc/wiki/2_layout.dwiki
new file mode 100644
index 0000000000000000000000000000000000000000..223fdb55748e646bc0ed740383579b0a89bc696e
--- /dev/null
+++ b/doc/wiki/2_layout.dwiki
@@ -0,0 +1,183 @@
+
+====== Édition du dessin des masques des circuits analogiques ======
+
+— //[[mickael.fiorentino@polymtl.ca|Mickael Fiorentino]] 2019/07/20// ; //[[erika.miller-jolicoeur@polymtl.ca|Erika Miller-Jolicoeur]] 2019/07/20// —
+
+Cette deuxième partie du tutoriel traite de l’édition du dessin des masques de l’inverseur. Avant de commencer, assurez-vous d'avoir complété la [[tutos:inverseur:1_schema|première partie]]. 
+
+Nous utiliserons une méthode semi-automatique pour concevoir le dessin des masques de l’inverseur à partir de son schéma. Ensuite, nous passerons au travers des étapes de vérifications physiques:
+
+  * Vérification des règles de dessins avec l’outil **DRC** (//Design Rules Check//).
+  * Vérification de l'intégrité électrique du circuit avec l'outil **LVS** (//Layout vs Schematic//).
+
+Enfin, nous allons exporter le modèle du circuit final, incluant les capacités parasites, afin de réaliser une simulation post-implémentation.
+
+Pour démarrer l’éditeur de dessin des masques de //Virtuoso// sélectionnez: ''Launch -> Layout XL'' à partir de la fenêtre d’édition de schéma de l’inverseur. 
+
+<imgcaption fig:layxl| Éditeur de dessin des masques>
+{{2_layxl2.png|Éditeur de dessin des masques}}
+</imgcaption>
+
+===== Raccourcis clavier =====
+
+Le tableau ci-dessou liste les raccourcis clavier que vous serez amené à utiliser dans le cadre de ces laboratoires.
+
+^**Raccourci**  ^**Description**                                                                      ^
+|''ESC''        |//Echap//: Sortir d’un mode                                                          |
+|''f''          |//Focus//: Visualiser l’ensemble du dessin des masques                               |
+|''z''          |//Zoom//: Zoomer sur la zone sélectionnée. ''Shift-Z'' (zoom), ''Ctrl-Z'' (dézoom)   |
+|''q''          |//Properties//: Éditer les propriétés des objets                                     |
+|''i''          |//Instance//: Instancier des éléments du gestionnaire de librairies                  |
+|''m''          |//Move//: Déplacer les objets.                                                       |
+|''s''          |//Stretch//: Déplacer les objets.                                                    |
+|''p''          |//Path//: Créer un chemin de largeur minimale pour la couche sélectionnée            | 
+|''r''          |//Rectangle//: Créer un rectangle de la couche sélectionnée                          |
+|''k''          |//Ruler//: Tracer des règles sur le dessin des masques. ''Shift-K'' pour les effacer |
+|''o''          |//Contact//: Instancier des contacts de la librairie                                 |
+
+==== Affichage ====
+
+<imgcaption fig:display| Options d'affichage>
+{{2_display.png|Options d'affichage}}
+</imgcaption>
+
+En suivant: ''Options -> Display'' (ou en utilisant le raccourcis ''e'') vous pouvez modifier les options d’affichage de //Virtuoso//. Modifiez la résolution de la grille (''Grid Controls'') et les modes d’amorçage (''Snap Modes'') tel que le montre la <imgref fig:display>.
+
+//Remarque: Les snap-spacing doivent être inférieur à 0.005, faute de quoi vous aurez des erreurs de DRC de type off-grid//.
+
+==== Génération du dessin des masques ====
+
+Il est possible de générer le dessin des masques des transistors de l’inverseur à partir de son schéma. Cela vous permettra, d’une part de ne pas avoir à le faire à la main, mais surtout d’automatiser la modification des tailles du transistor en fonction des paramètres que vous sélectionnez dans l’éditeur de schéma et dans le dessin des masques.
+
+Sélectionnez: ''Connectivity -> Generate -> All From Source'', et assurez-vous de (dé)sélectionner les options, comme le montre la <imgref fig:laygen>. En particulier, décochez la case ''PR Boundary'', et utilisez la couche ''Metal1 pin'' pour les pins d’entrées/sorties. Dans l’onglet ''I/O Pins'' sélectionnez: ''Create Label As -> Label'', puis: ''Options -> Layer Name/Layer Pins -> Same as Pin''. Vous devriez voir apparaitre à l’écran le dessin des masques des deux transistors, ainsi que les 4 pins d’entrées/sorties. Utilisez la combinaison de touches ''Shift+F'' pour afficher le détail des couches physiques. Pour remplacer ou ajouter un transistor, sélectionnez le dans l’éditeur de schéma, puis dans l’éditeur de dessin des masques faites: ''Connectivity -> Generate -> Selected From Source''. Pour afficher les connexions entre les différents points du circuit faites: ''Connectivity -> Incomplete Nets -> Show/Hide All''.
+
+<imgcaption fig:laygen1| Generate>
+{{2_laygen1.png|Generate}}
+</imgcaption><imgcaption fig:laygen2| I/O Pins>
+{{2_laygen2.png|I/O Pins}}
+</imgcaption>
+
+=== Modèle de cellule standard ===
+
+Les délimitations d’une cellule sont définies par sa //Boundary Box//. Il s’agit d’une couche virtuelle permettant de délimiter la taille de la cellule. Les cellules standards sont conçues dans un canevas (//Template//), dont la hauteur est définie et doit rester fixe, et dont la largeur peut varier. Cette pratique est utile en conception numérique, car elle facilite l’automatisation du placement et du routage des cellules.
+
+Pour concevoir le dessin des masques de l’inverseur, nous allons utiliser le //template// de la librairie standard ''gsclib045_tech''. Pour l’instancier sélectionnez: ''i -> Library -> gsclib045_tech'', puis: ''Cell -> cellTmpl'', avec: ''View -> layout''. Positionnez le //exactement// à l’origine du dessin des masques, et adaptez sa largeur en modifiant la propriété: ''Cell Width -> 0.5''.
+
+=== Placement et routage manuel ===
+
+<imgcaption fig:invlayout| Dessin des masques>
+{{2_invlayout.png|Dessin des masques}}
+</imgcaption>
+
+À ce stade, il ne vous reste plus qu’à effectuer le placement et le routage de l’inverseur. Sélectionnez les couches pertinentes dans le menu ''Layers'' avant chaque édition. Utilisez la touche ''p'' pour tracer les chemins des connexions. Utilisez la touche ''r'' pour créer des rectangles si nécessaires. Utilisez la touche ''o'' pour instancier des contacts.
+
+La convention veut qu’on utilise du ''Metal2'' pour les connexions entre les cellules et du ''Metal1'' pour les alimentations et les connexions internes. Vous devrez donc utiliser des contacts ''M1_M2'' et ''M1_PO'' pour les entrées/sorties. Assurez-vous de positionner les pins d’entrées/sorties aux bons endroits du dessin, et positionnez vos transistors au milieu du //template//. D’une manière générale, //soyez précis// dans le positionnement des différentes couches. La <imgref fig:invlayout> vous donne une cible à atteindre.
+
+===== Vérifications =====
+
+Une fois que votre dessin des masques est terminé, il est essentiel de procéder aux deux étapes de vérification suivantes:
+
+  * **Design Rule Check**: Le DRC permet de s’assurer que les règles de dessin sont respectées. Ces règles constituent une abstraction des contraintes physique de la technologie utilisée. En vérifiant que le dessin des masques satisfait à ces contraintes, on s’assure que le procédé de fabrication n’altérera pas le fonctionnement du circuit.
+  
+  * **Layout Versus Schematic**: Le LVS permet de s’assurer que le dessin des masques est électriquement équivalent au schéma du circuit. Elle permet d’éviter les circuits ouverts et les courts circuits qui peuvent apparaitre par inadvertance dans le dessin des masques.
+
+Nous utiliserons l’outil PVS (//Physical Verification System//) de //Cadence// pour réaliser ces deux étapes de vérification. Si le fichier de configuration ''setup.csh'' a été utilisé pour initialiser l’environnement, le menu PVS devrait être intégré dans //Virutoso//. Pour le LVS et le DRC, nous allons configurer l’outil à partir de fichiers (''.rul'') contenant des règles spécifiques à la technologie ''GPDK45''.
+
+Par défaut, le DRC et le LVS s’exécutent respectivement dans les dossiers ''PVSDRC'' et ''PVSLVS''. De même que pour la simulation, ces dossiers sont sur le réseau ce qui peut ralentir l’exécution des outils et prendre beaucoup de place dans votre compte utilisateur. Nous allons donc créer deux dossiers pour les vérifications, ''drc'' et ''lvs'', sur les machines locales:
+
+<code:bash>
+[shell]% mkdir -p /export/tmp/<user>/verifications/{drc,lvs}
+</code>
+
+==== DRC ====
+
+Pour démarrer l’outil de DRC, sélectionnez: ''PVS -> Run DRC''. Avant de lancer la procédure, nous allons modifier le dossier d’exécution et configurer les règles comme le montre la <imgref fig:drc>.
+
+  * Dans le menu ''Run Data'' Sélectionnez: ''Run directory -> /export/tmp/<user>/verifications/drc''
+  * Dans le menu ''Rules'' Sélectionnez: ''Technology Mapping File -> /CMC/kits/AMSKIT616_GPDK/ tech/gpdk045/pvtech.lib''. Puis, sélectionnez ''gpdk045_pvs'' dans le menu déroulant. Le fichier contenant les règles pour le DRC devrait être: ''/CMC/kits/AMSKIT616_GPDK/tech/gpdk045/pvs/ pvlDRC.rul''.
+
+Parcourez les autres menus pour vous convaincre que les informations qu’ils contiennent sont pertinentes. Finalement, pour lancer la procédure de DRC cliquez sur ''Submit''.
+
+<imgcaption fig:drcdata| Répertoire>
+{{2_drcdata.png|Répertoire}}
+</imgcaption> <imgcaption fig:drcrules| Règles>
+{{2_drcrules.png|Règles}}
+</imgcaption>
+
+Pendant l’exécution du DRC, une nouvelle fenêtre contenant les //logs// de PVS s’ouvre. Elle permet de vérifier que l’exécution du DRC s’est bien passée, et donne des indications sur la nature des problèmes le cas échéant. À la fin de l’exécution, le DRC //Debug Environment// s’ouvre. Cette fenêtre contient la liste des erreurs de DRC trouvées par l’outil en analysant votre dessin des masques, comme le montre la <imgref fig:lvsdebug>. En cliquant sur une ligne vous obtenez le détail de l’erreur, et //Virtuoso// zoom automatiquement sur la zone concernée dans votre dessin des masques. Vous devez corrigez vos erreurs et relancer le DRC jusqu’à ce qu’il n’y en ai plus aucune.
+
+<imgcaption fig:drcdebug| DRC Debug Environment>
+{{2_drcdebug.png|DRC Debug Environment}}
+</imgcaption>
+
+==== LVS ====
+
+Pour démarrer l’outil de LVS, sélectionnez: ''PVS -> Run LVS''. De même que précédemment, nous allons modifier le dossier d’exécution, configurer les règles et les fichiers de sortie comme le montre la <imgref fig:lvs>.
+
+  * Dans le menu ''Run Data'' Sélectionnez: ''Run directory -> /export/tmp/<user>/verifications/lvs''
+  * Dans le menu ''Rules'' Sélectionnez: ''Technology Mapping File -> /CMC/kits/AMSKIT616_GPDK/ tech/gpdk045/pvtech.lib''. Puis, sélectionnez ''gpdk045_pvs'' dans le menu déroulant. Le fichier contenant les règles pour le DRC devrait être: ''/CMC/kits/AMSKIT616_GPDK/tech/gpdk045/pvs/ pvlLVS.rul''. En complément des règles de la technologie, il faut ajouter le fichier de contrôle: ''/CMC/kits/AMSKIT616_GPDK/tech/gpdk045/pvs/pvs_control_file''.
+  * Dans le menu ''Output'' Cochez: ''Additional Output -> Create Quantus QRC Input Data''.
+
+<imgcaption fig:lvsdata| Répertoire>
+{{2_lvsdata.png|Répertoire}}
+</imgcaption> <imgcaption fig:lvsrules| Règles>
+{{2_lvsrules.png|Règles}}
+</imgcaption>
+
+Pendant l’exécution du LVS, un nouvel onglet s’ouvre dans la fenêtre des //logs// de PVS. À la fin de l’exécution, le LVS //Debug Environment// liste les erreurs de LVS trouvées par l’outil en analysant votre dessin des masques, comme le montre la <imgref fig:lvsdebug>. Ici par exemple on observe une différence entre les labels du schéma et ceux du //layout// (inexistant). Les noms des objets sont des liens qui vous guideront vers les zones concernées de votre schéma ou de votre //layout//. C’est à vous de juger de l’importance des erreurs de LVS. Corrigez ce qui vous semble nécessaire pour obtenir un circuit fonctionnel.
+
+<imgcaption fig:lvsdebug| LVS Debug Environment>
+{{2_lvsdebug.png|LVS Debug Environment}}
+</imgcaption>
+
+===== Simulation du dessin des masques =====
+
+La simulation du dessin des masques (aussi appelée simulation post-implémentation) permet de prendre en compte les éléments //parasites// qui résultent de l’interaction entre les couches physiques composant le circuit. Ces simulations sont importantes pour évaluer de manière plus exacte les délais et la puissance consommée par le circuit (entre autre). La procédure pour simuler le dessin des masques se déroule donc en deux étapes: La première étape consiste à extraire les résistances et les capacités parasites du circuit, et la deuxième étape consiste à simuler le circuit en prenant en compte les parasites.
+
+==== Extraction des parasites ====
+
+L’extraction des parasites nécessite un résultat sans erreur du LVS, et sera réalisée avec l’outil //Quantus QRC Extraction//. Pour ce faire, sélectionnez ''QRC -> Run PVS - Quantus QRC''. Dans la fenêtre qui s’ouvre (<imgref fig:qrcinit>), sélectionnez: ''PVS Data Directory -> /export/tmp/<user>/verifications/lvs/svdb'', puis: ''Quantus QRC Tech Lib -> /CMC/kits/AMSKIT616_GPDK/tech/gpdk045/pvtech.lib'', et finalement: ''Technology -> gpdk045_pvs''. Dans la nouvelle fenêtre qui s’ouvre (<imgref fig:qrc>):
+
+  * Dans le menu ''Setup'' Sélectionnez: ''Ruleset -> rcx_typical''. On veut créer une vue //extracted//, dans ''Output -> Extracted View'', assurez vous que c’est la bonne cellule et librairie, la vue est ''view -> av_extracted''.
+  * Dans le menu ''Extraction'' Sélectionnez ''Extraction Type -> RC'' puis ''Name Space -> Schematic Names''. Choisissez ''Cap Coupling Mode -> Coupled'' ainsi que ''Ref Node -> vss'', ou le nom de la pin de référence dans votre schéma.
+  * Dans le menu ''Netlisting'' Sélectionnez ''Parasitic Capacitor Models -> Do Not Include'' ainsi que ''Parasitic Resistor Models -> Do Not Include'' afin d’utiliser les composants de la librairie ''analogLib''.
+
+<imgcaption fig:parasites| Parasites extraits>
+{{2_qrcextracted.png|Parasites extraits}}
+</imgcaption>
+
+À la fin de l’exécution de QRC, une fenêtre devrait vous annoncer que la vue a été créée. Dans le gestionnaire de librairie, ouvrez la nouvelle vue générée (''av_extracted''). Faites ''Shift+F'' pour afficher le détail du dessin des masques. Si vous zoomez suffisamment, vous pouvez voir les différents parasites, tel que le montre la <imgref fig:parasites>.
+
+<imgcaption fig:qrcinit| Initialisation>
+{{2_qrcinit.png|Initialisation}}
+</imgcaption> <imgcaption fig:qrcdata| Configuration>
+{{2_qrcsetup.png|Configuration}}
+</imgcaption> <imgcaption fig:qrcextract| Extraction>
+{{2_qrcextract.png|Extraction}}
+</imgcaption> <imgcaption fig:qrcnetlist| Liste des interconnexions>
+{{2_qrcnetlist.png|Liste des interconnexions}}
+</imgcaption>
+
+==== Configuration de la simulation ====
+
+Il faut créer une vue //config// qui permettra de choisir la vue à utiliser pour simuler la cellule. Dans le ''Library Manager'', placez vous dans la cellule du banc d’essai (''INV_TB''), puis sélectionnez: ''File -> New -> Cell View'', avec: ''Type -> config'', tel qu’illustré à la <imgref fig:configview>. Dans la nouvelle fenêtre, sélectionnez: ''Use Template -> spectre''. Modifiez les champs: ''View -> schematic'', et: ''Library List -> ele8304'' pour identifier les cellules et librairies nécessaires. Modifiez ''View List'' pour ajouter la vue ''av_extracted''. Vous devriez obtenir un résultat similaire à la <imgref fig:configparam>. Dans la fenêtre du ''Hierarchy Editor'' vous pouvez choisir la vue qui sera simulée en faisant un clic droit sur la cellule de l’inverseur, puis en sélectionnant: ''Set Cell View -> av_extracted''. Enfin, mettez à jour les vues avec: ''View -> Update''. Vous remarquez que les nouveaux composants contenant les éléments parasites ont été ajouté à la hiérarchie. Notez qu’il faut que l’environnement de simulation soit lié à la fenêtre //config// (ce qui peut être vérifié par le titre de la fenêtre ''ADE L'', tel qu’illustré à la <imgref fig:configadel>). Pour ce faire, il faut ouvrir ''ADE L'' via la vue //config//. Le simulateur par défaut est //AMS//, changez pour //spectre// avant de continuer. Sélectionnez: ''Setup -> Simulator/Directory/Host -> Simulator: spectre; Project Directory:/export/tmp/<user>/simulations''.
+
+==== Simulation post-implémentation ====
+
+Chargez la configuration que vous avez sauvegardée précédemment avec: ''Session -> Load State''. Si vous n’avez pas de sauvegarde, configurez l’environnement comme à la section, et [[tutos:inverseur:1_schema:#Simulation transitoire|configurez la simulation transitoire]]. Faites ensuite une nouvelle sauvegarde de votre environnement, de façon à le conserver dans un fichier distinct.
+
+<imgcaption fig:simupara| Simulation des vues schematic et av_extracted>
+{{2_simupara.png|Simulation des vues schematic et av_extracted}}
+</imgcaption>
+
+Augmentez la finesse de la simulation en sélectionnant ''Choose Analyses -> Accuracy: conservative''. Puis lancez la simulation avec: ''Netlist and Run''. Vous obtenez la simulation incluant les parasites spécifiques au dessin des masques. Pour vous en assurer, vérifiez que les parasites sont bien inclus dans la //netlist// (''Simulation -> Netlist -> Display''). Puis, comparez les résultats par rapport à la simulation sans parasites. Ouvrez en parallèle la vue ''config'' et changez la vue de la cellule ''INV'' pour ''schematic''. Mettez à jour la hiérarchie et sauvegardez. Enfin dans ''ADE L'', modifiez: ''plotting mode -> append'' pour ajouter la nouvelle simulation à la précédente puis: ''Netlist and Run''. Utilisez la barre de défilement en haut des chronogrammes pour afficher une transition de l’inverseur. Vous devriez obtenir un résultat similaire à la <imgref fig:simupara>. On remarque une très légère différence entre les deux courbes.
+
+<imgcaption fig:configview| Création>
+{{2_configview.png|Création}}
+</imgcaption> <imgcaption fig:configadel| ADE L lié>
+{{2_configadel.png|ADE L lié}}
+</imgcaption> <imgcaption fig:configparam| Configuration>
+{{2_configparam.png|Configuration}}
+</imgcaption> <imgcaption fig:configfinal| Hierarchy Editor>
+{{2_configfinal.png|Hierarchy Editor}}
+</imgcaption>
diff --git a/doc/wiki/3_approfondir.dwiki b/doc/wiki/3_approfondir.dwiki
new file mode 100644
index 0000000000000000000000000000000000000000..3822a9f8730b609a90b8becde1643a2f335870f2
--- /dev/null
+++ b/doc/wiki/3_approfondir.dwiki
@@ -0,0 +1,227 @@
+
+====== Utilisations avancées de l'environnement de simulation ======
+
+— //[[erika.miller-jolicoeur@polymtl.ca|Erika Miller-Jolicoeur]] 2019/07/20// ; //[[mickael.fiorentino@polymtl.ca|Mickael Fiorentino]] 2019/07/20// —
+
+Dans cette troisième partie du tutoriel il s’agit de poursuivre l’analyse de l’inverseur entamée dans la [[tutos:inverseur:1_schema|première]] et la [[tutos:inverseur:2_layout|deuxième]] partie. Pour cela, nous allons aborder des notions avacées de l’environnement de simulation de //Virtuoso//: **//Analog Design Environment//** (//ADE L//).
+
+Les principaux modes de simulations disponibles dans //ADE L// sont:
+
+  * //La simulation transitoire//: Permet d’obtenir la réponse temporelle du circuit dans un intervalle de temps donné, ainsi qu'à valider la fonctionnalité du circuit.
+
+  * //La simulation en courant continu//: Permet d’obtenir le point d’opération en courant continu du circuit, ainsi que les caractéristiques DC du circuit.
+
+  * //La simulation en courant alternatif//: Permet d’obtenir la réponse fréquentielle du circuit pour un petit signal autour du point d’opération.
+
+  * //La simulation du bruit//: Permet d’obtenir la densité spectrale de bruit autour du point d’opération.
+
+  * //La simulation paramétrique//: Permet d’obtenir l’ensemble des résultats de simulation en changeant la valeur d’une variable de manière itérative. 
+
+Les résultats obtenus à l'issu de ces simulations permettent de faire les ajustements nécessaires pour assurer que la linéarité, la précision, le gain, la réponse en fréquence, la consommation de puissance, et le bruit du circuit correspondent aux spécifications.
+
+Plusieurs outils sont diponibles dans //ADE L// pour faciliter l'analyse des résultats de simulations. En particulier, ce tutoriel couvre les outils suivants:
+
+  * //Les annotations//: Permettent d’afficher sur le schéma quelques informations choisies.
+  
+  * //L’impression//: Permet d’afficher le détails de toutes les variables du modèle au point d’opération.
+  
+  * //L’explorateur de résultats//: Permet de naviguer dans la base de donnée des résultats sauvegardés.
+  
+  * //La calculatrice//: Permet de réaliser des fonctions complexes à partir des résultats.
+
+//Remarque: Bien que les outils sont présentés pour un type de simulation spécifique, leur utilisation ne se limite pas à ce seul type de simulation.//
+
+===== Configuration =====
+
+<imgcaption fig:conf| Environnement de simulation>
+{{3_adel.png|Environnement de simulation}}
+</imgcaption>
+
+Nous allons poursuivre la simulation de la vue //av_extracted// débutée dans la [[tutos:inverseur:2_layout|deuxème partie]] du tutoriel. Sélectionnez ''INV_TB -> config'' puis ouvrez la vue config pour l’éditer: ''Open Configuration: yes; Open Top Cell View: no''. Faite un clic droit sur la ligne faisant référence à la cellule ''INV'', puis sélectionnez ''Set Cell View -> av_extracted''. Recalculez la hiérarchie et sauvegardez.
+
+Si vous avez préalablement sauvegardé l’état de votre simulation post-implémentation, vous pouvez le charger directement en double cliquant sur la vue de la cellule ''INV_TB''. Vous pouvez également le charger à partir de l’environnement de simulation //ADE L// en suivant: ''Session -> Load state'', avec l’option ''Load state option -> cellview'', et en sélectionnant sous le format ''Cellview'' l’état que vous avez enregistré avec la vue config. Assurez-vous que le nom de la vue dans l’entête de la fenêtre est bien ''config''.
+
+Alternativement, dans la vue ''config'' sélectionnez ''ADE L'', puis ''Setup -> Simulator/Directory/Host''. Assurez vous que le simulateur est bien ''spectre'', et que le répertoire du projet est: ''/export/tmp/<user>/simulations''.
+
+===== Simulation transitoire =====
+
+La simulation transitoire permet d’évaluer le comportement dynamique d’un circuit lorsqu’il est soumis à un ensemble de stimuli, comme c’est le cas par exemple de l’inverseur lorsqu’il est soumis aux stimuli du signal rectangulaire périodique généré par l’alimentation ''vpulse''. La valeur des conditions initiales est tirée de la solution du point d’opération continue (DC), sauf si spécifié autrement. Simuler le circuit correspond à résoudre des équations différentielles. Pour cela le simulateur fait un premier estimé puis converge itérativement vers le minimum local correspondant à la solution. Pour le reste de la simulation le simulatuer discrétise le temps en intervalle de temps suffisamment petits pour que des approximations par des polynômes de faibles degrés permettent d’évaluer la pente de la fonction différentielle.
+
+Pour configurer le type de simulation à effectuer, sélectionnez ''Analyses -> Choose'', puis choisissez: ''Analysis -> tran'', et: ''Stop Time -> 4u'', pour définir le temps de simulation. Enfin, sélectionnez: ''Accuracy -> moderate'' et ''OK''.
+
+Pour observer quelques signaux choisis, sélectionnez: ''outputs -> to be plotted -> select on design'', et sélectionnez les signaux ''vin'' et ''vout'' du banc d’essai. Finalement, pour lancer la simulation cliquez sur le bouton vert. Vous devriez obtenir un résultat similaire au chronogramme de la <imgref fig:tran>. Notez que pour séparer les courbes vous devez sélectionner: ''Graph -> Split All Strips''.
+
+<imgcaption fig:tran| Simulation transitoire de l’inverseur>
+{{3_tran.png|Simulation transitoire de l’inverseur}}
+</imgcaption>
+
+==== Consommation de puissance ====
+
+Nous allons utiliser les résultats de simulation pour estimer la consommation de puissance de l’inverseur lorsqu’il est stimulé à cette fréquence. Cela nous permettra de présenter les fonctionnalités offertes par les outils //Result Browser// et //Calculator//, bien que d’autres outils spécialisés de cadence permettent d’obtenir ce résultat. Il faut premièrement sauvegarder les tensions et courants de tous les noeuds du circuit.
+
+Dans //ADE L// sélectionnez ''Outputs -> Save All''. Pour les tensions (//Select signals to ouput//), l’option par défaut (//allpub//) permet de sauvegarder tous les signaux publics, c'est à dire tous les fils visible, ce qui est suffisant dans notre cas. Il est possible de sauvegarder directement la puissance des composants, pour comparer avec ce que nous calculerons. Pour cela nous allons sélectionner le total: ''Select power signals to output -> total''. Finalement, nous utiliserons le courant pour calculer la puissance: ''Select devices currents -> all''. Enfin, sélectionnez ''Netlist & Run'' pour mettre à jour les résultats avec ces nouvelles configurations et lancer de nouveau la simulation.
+
+<imgcaption fig:saveall| Sauvegarde des signaux>
+{{3_saveall.png|Sauvegarde des signaux}}
+</imgcaption>
+
+==== Gestionnaire de résultats ====
+
+Le gestionnaire de résultats (//Result Browser//) est très pratique pour explorer les chronogrammes des signaux aux différents niveaux de l’architecture du circuit. Dans //ADE L//, décochez l’option ''plot -> vin, vout'', cela va permettre de simuler le circuit de nouveau sans écraser la configuration des chronogrammes réalisés dans le //Result Browser//. Par la suite, ouvrez-le avec ''Tools -> Result Browser''. La fenêtre de résultat s’ouvre avec un navigateur de la hiérarchie du circuit et des modes de simulation à gauche de la fenêtre, comme à la <imgref fig:rbinterface>. Cliquez sur ''+'' pour étendre les résultats et allez dans ''tran'' pour voir les signaux présents dans le schéma ''INV_TB''. Faites de même pour atteindre les étages inférieurs du schéma.
+
+Glissez-déposez les signaux d’intérêt, par exemple le courant dans la charge ''I C0:1''. Vous pouvez séparer en sous-section l’affichage des différents signaux en les glissant aux limites de la zone graphique, jusqu’à l’affichage d’une ligne jaune pointillée et de relâcher, comme sur la <imgref fig:rbaddsignal>. Pour mesurer la puissance, nous allons utiliser les signaux ''V netx'' (qui correspond à VDD) et ''I0 -> I NM0:d, I:PM0:s''.
+
+//__Remarque__: La convention de signe pour les courants utilisés dans //Virtuoso// est qu’ils sont positifs s’ils entrent dans un port et négatifs s’ils en sortent, d’où les ports utilisés pour que le courant soit positif.//
+
+Glissez-déposez ces signaux dans la fenêtre de simulation pour que l’on puisse les utiliser dans la calculatrice pour faire le calcul de la puissance. Lorsque vous changez le circuit ou réalisez de nouvelles simulations, il est possible de mettre à jour la fenêtre en faisant ''Ctrl+R'' ou encore ''File -> Reload -> All Windows''.
+
+ <imgcaption fig:rbinterface| Interface>
+ {{3_resultbrowser.png|Interface}}
+ </imgcaption> <imgcaption fig:rbaddsignal| Ajout de signaux>
+ {{3_resultbrowseraddsignal.png|Ajout de signaux}}
+ </imgcaption>
+
+==== Calculatrice ====
+
+Ouvrez maintenant la calculatrice avec ''Tools -> Calculator''. L’outil calculatrice permet de calculer des valeurs, des tableaux de valeurs, ou des courbes à partir des signaux enregistrés par chaque type de simulation. La syntaxe est particulière, et consiste à sélectionner chaque opérandes puis l’opérateur. Il est possible d’accumuler des termes dans la pile qui seront par la suite dépilés pour les ajouter aux nouveaux termes en construction. Dans le cas qui nous intéresse, la consommation de puissance correspond à la somme des courants dans chacun des transistors, multipliée avec le signal correspondant à VDD, ou la constante 1. Pour sélectionner des résultats de simulation, sélectionnez ''Wave'' dans les options du haut de la calculatrice. Cliquez maintenant sur les courbes de courant ''/I0/NM0/D, /I0/PM0/S'' de chacun des transistors puis cliquez sur ''+''. Cliquez maintenant sur la courbe ''/netx'' (qui correspond au nom du fil correspondant à VDD) et ''\times'', le résultat devrait être semblable à la <imgref fig:powercalc>. Cliquez sur le bouton ''plot'' à côté de la case ''clip'' pour générer et afficher le chronogramme du résultat.
+
+<imgcaption fig:powercalc| Calculatrice>
+{{3_powercalc.png|Calculatrice}}
+</imgcaption>
+
+Vous pouvez comparer le résultat avec la courbe de consommation de puissance totale calculée par spectre. La différence est significative, cela est dû au modèle du transistor qui inclus d’autres contributions que le courant ''ids'' pour le calcul de sa consommation de puissance. Nous allons maintenant déterminer la puissance moyenne, maximale et l’énergie consommée. Assurez vous de sélectionner la courbe correspondant à la puissance calculée précédemment, puis dans le bas de la fenêtre ''Function Panel -> All -> average'' puis ''plot''. Le résultat numérique est affiché dans le buffer de la calculatrice. Pour déterminer la valeur maximale, cliquez de nouveau sur la courbe de la puissance puis ''Function Panel -> ymax'' et puis ''plot''. Le calcul de l’énergie est réalisé en intégrant dans le temps la consommation de puissance. Sélectionnez la courbe de la consommation puis, ''Function Panel -> iinteg'' et ''plot''. Le résultat obtenu est en Joules(J). Vous devriez obtenir un résultat équivalent à la <imgref fig:powerresult>.
+
+<imgcaption fig:powerresult| Résultat graphique>
+{{3_powerresult.png|Résultat graphique}}
+</imgcaption>
+
+===== Calcul du point d’opération =====
+
+Le calcul du point d’opération du système correspond à l’analyse grand signal du circuit. C’est-à-dire que les sources sont considérées comme étant constantes, les capacités sont remplacées par des circuits ouverts, et les inductances par des courts-circuits. Par la suite, le simulateur calcule les tensions, les courants, la puissance, etc. des différents composants du circuit ainsi modifié. Les résultats obtenus sont utilisés par les analyses //ac//, //noise//, et d’autres analyses dans le domaine fréquentiel, pour linéariser le comportement des modules non linéaires et des transistors autour de ce point. Il est donc important de s’assurer que le point d’opération est calculé pour les conditions dans lesquelles le circuit va opérer. Le point d’opération peut aussi être calculé en fonction de paramètres ou de variables, ce qui permet d’obtenir des courbes caractéristiques. Dans des circuits complexes, la convergence vers un point d’opération peut s’avérer instable, il faut donc ajouter des valeurs initiales pour aider le simulateur à converger vers un point d’opération stable.
+
+==== Simulation DC ====
+
+La simulation //dc// est principalement employée pour deux types d’usages:
+  - Trouver le point d’opération DC du circuit,
+  - Obtenir les courbes caractéristiques DC en faisant varier les paramètres appropriés.
+
+Dans //ADE L// désactivez la simulation de l’analyse temporelle: ''Enable -> tran'', et réactivez la génération des courbes: ''plot -> vin, vout''. Pour obtenir les courbes caractéristiques, dans la fenêtre //ADE L// sélectionnez: ''Analyses -> Choose''. Choisissez ''Analysis -> dc'' puis sélectionnez: ''Sweep Variable -> Component Parameter'', puis: ''Select Component'', et choisissez ''vpulse'' sur le banc d’essai. Sélectionnez: ''Parameter Name -> dc''. Configurez la rampe de tension avec: ''Sweep Range -> start: 0, stop: 1''. Enfin, ''sweep Type -> linear'' suivi de ''Number of Steps -> 500''. Cliquez sur ''OK''. Sélectionnez les signaux ''vin'' et ''vout'' comme les sorties à tracer et lancez la simulation. Vous devriez obtenir une figure similaire à la <imgref fig:dc>
+
+Pour obtenir le point d’opération, cliquez sur la ligne de la simulation DC réalisée précédemment puis ''Choose Analyses''. Cochez ''Save DC Operating Point'', vous pouvez laisser le reste tel quel. Lancez la simulation, vous remarquerez qu’aucun nouveau résultat ne s’affiche. C’est parce qu’il n’y a pas de graphique, seulement des données pour les différents composants du circuit. Pour visualiser les résultats du point d’opération sélectionnez: ''Results -> Annotate -> DC Node Voltages'' suivi de ''Results -> Annotate -> DC Operating Points''. Naviguez dans la hiérarchie du circuit avec ''Shift+E/ Ctrl+E'' pour descendre/monter en combinaison avec un clic sur le symbole du circuit dans le banc d’essai. Visualisez les tensions et paramètres des noeuds et transistors.
+
+<imgcaption fig:dc| Fonction de transfert DC>
+{{3_dc.png|Fonction de transfert DC}}
+</imgcaption>  
+
+Le point d’opération obtenu est celui correspondant à une entrée de ''vin'' de 0V, mais ce n’est pas approprié pour les simulations subséquentes puisque la pente de la courbe caractéristique est nulle en cet emplacement. La linéarisation du système autour de ce point implique que l’amplitude d’un petit signal de sortie soit nulle. On veut plutôt se placer dans la zone de saturation des transistors, autour du seuil de basculement de l’inverseur, qui correspond au point où ''vin = vout''. Cette zone est illustrée sur la <imgref fig:zoneSat> entre les deux lignes verticales. Le point de transition correspond à environ VDD/2, soit une entrée ''vin'' de 0.5V. Pour le mesurer, ajoutez des marqueurs avec ''m'' au dessus de la zone d’intérêt puis un clic-glissé pour le déplacer jusqu’au point correspondant à ''vin=vout''. Pour les marqueurs verticaux, sélectionnez ''Marker -> Create Marker'' suivi de ''Vertical'' et de la valeur en abscisse désirée.
+
+Pour modifier le point d’opération DC calculé, faut donc modifier la configuration de la source ''vpulse'' dans le schéma du banc d’essai. Dans le schéma ''INV_TB'', sélectionnez la source ''vpulse'' puis appuyez sur ''q'' pour obtenir ses propriétés, ''DC Voltage -> 0.5'', le point mesuré précédemment. Sauvegardez les modifications avec ''Check and Save'', puis relancez la simulation. Observez les nouveaux résultats aux différents niveau de la hiérarchie du schéma.
+
+<imgcaption fig:zoneSat| Zone de saturation>
+{{3_dczonesat.png|Zone de saturation}}
+</imgcaption>
+
+==== Annotations ====
+
+Pour avoir plus de détails sur l’état du transistor à un point donné, il est possible d’accéder au détail de tous les paramètres du composant. Dans //ADE L sélectionnez ''Results -> Annotate -> DC Operating Points''. Parcourrez la hiérarchie avec ''Shift+E'' et sélectionnez chacun des transistors. Une liste de tous les paramètres mesurés lors de la simulation DC est affichée comme à la <imgref fig:printoppoint>. Pour une simulation transitoire il est aussi possible d’afficher les résultats associés à un instant particulier avec la fonction ''Results -> Annotate -> Transient Operating Points''. On peut par exemple obtenir la tension seuil ''vth'', la tension grille source ''vgs'', la tension drain-source ''vds'', la conductance ''gm'', le courant de drain ''id'', et la conductance de sortie ''gds''correspondant à ''1/rout''.
+
+<imgcaption fig:printoppoint| Résultat de l’impression pour nmos1v>
+{{3_printoppoint.png|Résultat de l’impression pour nmos1v}}
+</imgcaption>
+
+La fonction ''annotate'' permet de rassembler un ensemble des paramètres obtenus avec la fonction ''print''. On peut donc choisir d’afficher sur le schéma: les paramètres, les points d’opérations, le nom des noeuds ou les tensions des composants par exemple. Pour annoter le schéma, il faut réaliser une simulation du circuit, puis dans //ADE L// il faut sélectionner ''Results -> Annotate -> DC Operating Points'', ou une autre option selon ce qui est désiré. On vous encourage de toutes les essayer. Dans le schéma, descendez dans la hiérarchie avec ''Shift+E'' pour visualiser les modifications de l’affichage tel qu’illustré ici.
+
+<imgcaption fig:anncomponent| Component Parameters>
+{{3_annextractedcomponent.png|Component Parameters}}
+</imgcaption> <imgcaption fig:annoppoint| DC Operating Points>
+{{3_annextractedoppoint.png|DC Operating Points}}
+</imgcaption>
+
+Ici nous obtenons 4 paramètres du transistor, mais il y en a davantage comme nous l’avons vu avec l’option ''print''. Pour modifier les paramètres visibles sur le schéma, dans le schéma  ''INV_TB'', ouvrez la fenêtre de configuration avec ''View -> Annotations -> Setup''. Inscrivez ''Cell -> *mos1v'' pour modifier la configuration des deux types de transistors à la fois. Une liste des paramètres communs s’affiche, ce sont ceux sous la catégorie ''DC Operating Point'' que nous allons modifier. Double-cliquez sur les cases ''Expression'' pour en modifier le contenu tel qu’indiqué dans la <imgref fig:annotatesetup>. Vous remarquerez qu’il est possible de réaliser des opérations mathématiques entre des paramètres. Notez que le paramètre ''region'' donne un chiffre qui correspond au mode d’opération du transistor. Vous trouverez dans le tableau suivant les régions associées. Il s’agit d’une configuration pour vous montrer ce qu’il est possible de faire, vous pourrez la modifier selon vos besoins spécifiques. Pour réinitialiser les modifications sélectionnez ''View -> Annotations -> Design Defaults''.
+
+^**Région**  ^**Description**  ^
+|0           |Coupure          |
+|1           |Triode           |
+|2           |Saturation       |
+|3           |Sous-seuil       |
+|4           |Claquage         |
+
+<imgcaption fig:annotatesetup| Configuration des annotations>{{annotatesetup.png|Configuration des annotations}}</imgcaption>
+
+===== Lien avec les équations analytiques =====
+
+Afin de faire le lien entre le fonctionnement du circuit réalisé dans //Cadence// et les équations analytiques que nous utilisons pour les transistors, il peut être pratique de visualiser la progression des différents paramètres du transistor, tels que ''gm'', ''vth'', etc. Les techniques précédentes (//print// et //annotate//) permettent de visualiser les paramètres pour un point d’opération donné, mais il peut être pratique de les visualiser pour une plage de valeurs.
+
+Assurez-vous d’être au niveau de la hiérarchie du layout ou du schéma contenant les transistors d’intérêt avec la combinaison des touches ''Shift+E'' et ''Ctrl+E''. Dans //ADE L// sélectionnez ''Outputs -> To be saved -> Select OP Parameters''. Le dessin des masques s’affiche, sélectionnez les deux transistors, puis ''ESC''. Dans //ADE L// un onglet ''Save Operating Points'' est apparu à la place des sorties avec les deux transistors (<imgref fig:oppointsaveadel>).
+
+<imgcaption fig:oppointsaveadel| ADE L>
+{{3_oppointsave.png|ADE~L}}
+</imgcaption>
+
+Choisissez les paramètres à sauvegarder en appuyant sur le bouton avec trois points à droite de chacun des éléments et sélectionnez, par exemple, ''gm'', ''gds'', ''vth'', et ''region''  (<imgref fig:oppointselectparam>).
+
+<imgcaption fig:oppointselectparam| Sélection des paramètres>
+{{3_oppointselectparam.png|Sélection des paramètres}}
+</imgcaption>
+
+Configurez une simulation DC avec un balayage de la tension de la source en entrée de l’inverseur et lancez la simulation. Vous pouvez accéder aux résultats via le //Result Browser// sous les résultats de la simulation DC. Alternativement vous pouvez cocher les cases sous la colonne ''plot'' dans //ADE L// pour que les courbes soient affichées automatiquement. Vous devriez obtenir un résultat analogue à la <imgref fig:oppointsimu>. Le paramètre ''region'' permet de voir la plage d’entrée associée à chaque région d’opération et donc de faire le lien avec les équations associées à chacune de celles-ci. De plus, on peut constater que ''vth'' varie selon la tension ''vds'', tel qu’attendu. ''gds'', qui correspond à la conductance de sortie du transistor, ou ''1/rds'', augmente lorsque le transistor est dans la région triode.
+
+ <imgcaption fig:oppointsimu| Résultats>{{oppointsimu.png|Résultats}}</imgcaption>
+
+Vous pouvez explorer les autres paramètres que vous connaissez et voir leur évolution selon la polarisation de l’inverseur. Par exemple, vous pouvez calculer le gain intrinsèque à chaque transistor avec la calculatrice en calculant ''gm/gds (=gm*rds)''.
+
+===== Simulation fréquentielle =====
+
+Lors de la conception d’un circuit, l'analyse de la réponse fréquentielle permet d’obtenir des informations complémentaires sur la stabilité du circuit et la fonction de transfert. Elle fonctionne en linéarisant les composants non linéaires autour du point d’opération DC avec des séries de Taylor. Il s’agit d’injecter un ou plusieurs signaux sinusoïdaux en régime petit signal au circuit à une fréquence donnée, et de mesurer l’amplitude et l’angle du signal de sortie. La même opération est réalisée pour un ensemble des fréquences balayées. Ces informations nous permettent de faire par exemple un diagramme de Bode, qui est utilisé par la suite pour déterminer la fréquence de coupure et les marges de gain et de phase.
+
+==== Analyses AC ====
+
+Pour réaliser une analyse AC, il faut indiquer au simulateur l’amplitude du signal AC des sources du circuit, par défaut il n’y en a pas. Nous voulons fournir en entrée un signal avec une amplitude qui se situe dans la zone linéaire du circuit. Pour cela, nous allons utiliser la zone identifiée avec des curseurs dans la simulation DC à la <imgref fig:zoneSat> pour déterminer l’amplitude du signal à injecter.
+
+Allez dans le schéma et allez dans les propriétés de ''vpulse'' avec la touche ''q''. Ajoutez environ l’amplitude mesurée précédemment, soit ''AC Magnitude -> 30m''. Le paramètre ''AC phase'' peut aussi être modifié avec un angle pour le signal d’entrée, ce qui est utile par exemple dans le cas d’un amplificateur opérationnel pour qu’il y ait une différence entre les deux entrées.
+
+Dans //ADE L//, sélectionnez ''Choose Analyses -> ac''. Sélectionnez les options suivantes: ''Sweep Variable -> Frequency'', suivi de ''Sweep Range -> Start-Stop'', avec ''Start -> 10'' et ''Stop -> 10G''. Configurez le pas du balayage des fréquences avec ''Sweep Type -> Logarithmic -> 50 Points Per Decade'' et finalement ''OK''.
+
+<imgcaption fig:bodeoutputsetup| Configuration des sorties>
+{{3_bodeoutputsetup.png|Configuration des sorties}}
+</imgcaption>
+
+==== Diagramme de Bode ====
+
+Les résultats de l’analyse fréquentielle sont généralement montrés sous la forme de diagrammes de Bode. Nous regarderons deux méthodes qui peuvent être employées pour les générer.
+
+Une première méthode consiste à configurer les sorties à afficher en utilisant les fonctions de la calculatrice. Sélectionnez ''Outputs -> Setup''. Donnez un nom: ''Name -> gain dB'', puis sélectionnez ''Calculator -> Open''. On veut réaliser l’expression suivante: ''dB20(abs(VF("/vout")/VF("/vin")))''. Sélectionnez ''vf'', puis les noeuds ''vout'' et ''vin'' dans le schéma, suivi de l'opérateur ''/''. L’option ''vf'' permet d’utiliser le noeud dans le schéma pour accéder aux résultats AC. Une alternative est d’utiliser l’option ''Wave'' puis de sélectionner directement les signaux AC ''vout'' et ''vin''. Par la suite, sélectionnez ''Function Panel -> All'' et ''Function -> abs'', suivi de ''Function -> dB20''. Retournez dans la fenêtre de configuration des sorties et sélectionnez ''Calculator -> Get Expression'', suivi de ''Add''. Il faut ajouter une courbe pour la phase. Ajoutez ''Name -> Phase'', puis ''Calculator -> Open''.Sélectionnez ''vf'', puis les noeuds ''vout'' et ''vin'' dans le schéma. Sélectionnez ''/'' puis ''Function -> phaseDegUnwrapped'' et ajoutez cette expression dans //ADE L// avec ''Calculator -> Get Expression'', suivi de ''Add'' et ''Ok''. Générez les graphiques avec ''Plot Outputs'' et séparez les courbes avec ''Split All Strips''. Vous devriez obtenir un résultat équivalent à la <imgref fig:bodeoutput>.
+
+<imgcaption fig:bodeoutput| Diagramme de Bode et amplitude de sortie de la simulation AC>
+{{3_bodeoutput.png|Diagramme de Bode et amplitude de sortie de la simulation AC}}
+</imgcaption>
+
+Une alternative est d’utiliser la fonction //Direct Plot//. Dans //ADE L// sélectionnez ''Results -> Direct Plot -> Gain & Phase''. Sur le schéma qui s’ouvre sélectionnez, dans l’ordre, les fils ''vout'' et ''vin'' puis ''ESC''. Cela va fournir le gain en dB et la phase en degrés de la sortie ''vout''. Cette méthode conduit au même résultat que précédemment, mais sera à refaire pour chaque nouvelle simulation.
+
+===== Densité spectrale de bruit =====
+
+Les dispositifs microélectroniques génèrent du bruit. Pour les caractériser, on utilise des ports qui permettent de faire abstraction de la topologie du circuit, et de mesurer le bruit équivalent en entrée et en sortie. Ces ports permettent aussi de mesurer plusieurs autres indicateurs de bruit. Il faut pour cela changer le schéma. Nous allons donc faire une copie que nous éditerons pour pouvoir se référer, si nécessaire, aux simulations précédentes.
+
+<imgcaption fig:noiseschematic| Schéma pour la simulation de bruit>
+{{3_noiseschematic.png|Schéma pour la simulation de bruit}}
+</imgcaption>
+
+Dans le ''Library Manager'', faites un clic droit sur ''INV_TB -> schematic -> Copy''. Dans la section ''To'', modifiez le nom de la cellule ''Cell -> IN_TB_NOISE''. Ouvrez et modifiez le schéma en remplaçant la source ''vpulse'' et la capacité de sortie par des ports de la librairie ''analogLib'', avec ''i'' suivi de ''Browse -> analogLib -> port -> spectre''. Le résultat devrait correspondre à la <imgref fig:noiseschematic>. Il faut ajouter une tension DC au port en entrée du circuit pour la condition initiale. Toutefois, la tension en sortie du port est le double de celle configurée (conditionnellement à des charges balancées), ajoutez donc 250m tel qu’illustré sur la <imgref fig:noiseportsetup>. ''Check & Save'' puis retournez dans ''Library Manager''. Créez une vue config avec ''New -> Cell View'' puis ''View -> config''. Référez vous à la [[tutos:inverseur:2_layout|deuxième partie]] du tutoriel pour réaliser la configuration de la vue et sélectionnez ''View to Use -> Set Cell View -> av_extracted''. Finalement, ouvrez //ADE L// à partir de la vue config puis modifiez le simulateur et le répertoire des résultats avec: ''Setup -> Simulator/ Directory/Host'', puis: ''Simulator -> Spectre'', et''Project Directory -> /export/tmp/<user>/simulations''.
+
+Pour réaliser une simulation de bruit, complétez les étapes suivantes:
+
+Sélectionnez ''Analyses -> Choose''. Choisissez ''Analysis -> noise'' puis sélectionnez ''Sweep Variable -> Frequency''. Sélectionnez la zone de balayage des fréquence, ''Sweep Range -> Start: 10, Stop: 10G'', puis sélectionnez ''Sweep Type -> Logarithmic, Points Per Decade: 50''. Finalement assignez les ports à leur fonction correspondante. Sélectionnez ''Output Port -> probe -> select'' et sélectionnez le port en sortie. Pour le port d’entrée, sélectionnez ''Input Port -> port -> select'' et sélectionnez le port d’entrée du circuit. 
+
+<imgcaption fig:noisesimconfig| Configuration de la simulation du bruit>
+{{3_noisesimconfig.png|Configuration de la simulation du bruit}}
+</imgcaption> <imgcaption fig:noiseportsetup| Configuration du port d'entrée>
+{{3_noiseportsetup.png|Configuration du port d'entrée}}
+</imgcaption> 
+
+Lancez la simulation puis générez les résultats avec ''Results -> Direct Plot -> Main Form'' puis choisissez l’une des différente figure. Par exemple, sélectionnez ''Function -> Input Noise'' avec ''Signal Level -> V/sqrt(Hz)'' ainsi que ''Modifier -> Magnitude''. Finalement, sélectionnez ''Plot'', vous devriez obtenir un résultat comme à la <imgref fig:noiseinputreferredswitching >. De manière analogue, vous pouvez aussi obtenir le bruit référé à la sortie, avec ''Function -> Output Noise'' puis ''plot''.
+
+<imgcaption fig:noiseinputreferredswitching| Référé à l'entrée>
+{{3_noiseinputreferred.png|Référé à l'entrée}}
+</imgcaption> <imgcaption fig:noiseoutputreferred| Référé à la sortie>
+{{3_noiseoutputreferred.png|Référé à la sortie}}
+</imgcaption>