Comment: | Added initial revision of ntt: new transformation tools for using bond graphs with Matlab. Copyright 2003 Dr. Dominic J. Diston. |
---|---|
Downloads: | Tarball | ZIP archive | SQL archive |
Timelines: | family | ancestors | descendants | both | origin/master | trunk |
Files: | files | file ages | folders |
SHA3-256: |
745f0b3e31dedb2bb7daf1f3c6a33398 |
User & Date: | geraint@users.sourceforge.net on 2003-10-20 17:10:30 |
Other Links: | branch diff | manifest | tags |
2003-10-20
| ||
17:10:31 | Link ancestry of version-0-1 to it's source branch check-in: c318408021 user: gawthrop@users.sourceforge.net tags: origin/master, trunk | |
17:10:30 | Created tag version-0-1 check-in: e62ad9467f user: gawthrop@users.sourceforge.net tags: origin/master, trunk, version-0-1 | |
17:10:30 |
Added initial revision of ntt: new transformation tools for using bond graphs with Matlab. Copyright 2003 Dr. Dominic J. Diston. check-in: 745f0b3e31 user: geraint@users.sourceforge.net tags: origin/master, trunk | |
2003-10-16
| ||
07:30:24 | ppp_int_obs now returns corrected as well as predicted output check-in: 4c9bb5509d user: gawthrop@users.sourceforge.net tags: origin/master, trunk | |
Added mttroot/ntt/COPYING version [8252cc0f12].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 | ntt: new transformation tools for using bond graphs with Matlab Copyright (C) 2003 Dr. Dominic J. Diston This program is free software; you can redistribute it and/or modify it 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 distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ^L GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year> <name of author> This program is free software; you can redistribute it and/or modify it 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 distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. <signature of Ty Coon>, 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. |
Added mttroot/ntt/bin/make_abg.m version [44a307073f].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | function abg = make_abg(system) global mtt_environment start_time = mttGetTime ; input = [] ; abg = [] ; switch class(system) case 'char', input = 'spec' ; case 'struct', if isfield(system,'representation') input = system.representation ; end end if strcmp(input,'spec') mttWriteNewLine ; mttNotify('Making "abg" representation') ; mttWriteNewLine ; if isempty(mtt_environment) mttNotify('...WARNING: No "env" definition => all domain references will be ignored') ; mttWriteNewLine ; mttNotify(' => paths will not be recognised') ; mttWriteNewLine ; end abg = mttCreateAcausalBondgraph(system) ; input = 'abg' ; end mttAssert(strcmp(input,'abg'),'Input representation not recognised') ; if isempty(abg) mttWriteNewLine ; mttNotify('Copying "abg" representation') ; mttWriteNewLine ; mttNotify('...INFO: Input already defined as a "abg": copying to Output') ; mttWriteNewLine ; mttWriteNewLine ; abg = system ; end elapsed_time = mttElapseTime(start_time) ; cpu_utilisation = round(100*elapsed_time.cpu/elapsed_time.clock) ; mttWriteNewLine ; mttNotify(['Completed in ',num2str(elapsed_time.clock),' seconds']) ; mttNotify([' (',num2str(cpu_utilisation),'%% cpu)']) ; mttWriteNewLine ; mttWriteNewLine ; |
Added mttroot/ntt/bin/make_cbg.m version [d10c4751f3].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 | function cbg = make_cbg(system) global mtt_environment start_time = mttGetTime ; input = [] ; abg = [] ; cbg = [] ; switch class(system) case 'char', input = 'spec' ; case 'struct', if isfield(system,'representation') input = system.representation ; end end if strcmp(input,'spec') mttWriteNewLine ; mttNotify('Making "abg" representation') ; mttWriteNewLine ; if isempty(mtt_environment) mttNotify('...WARNING: No "env" definition => all domain references will be ignored') ; mttWriteNewLine ; mttNotify(' => paths will not be recognised') ; mttWriteNewLine ; end abg = mttCreateAcausalBondgraph(system) ; input = 'abg' ; end if strcmp(input,'abg') if isempty(abg) abg = system ; end mttWriteNewLine ; mttNotify('Transforming from "abg" to "cbg"') ; mttWriteNewLine ; cbg = mttCreateCausalBondgraph(abg) ; input = 'cbg' ; end mttAssert(strcmp(input,'cbg'),'Input representation not recognised') ; if isempty(cbg) mttWriteNewLine ; mttNotify('Copying "cbg" representation') ; mttWriteNewLine ; mttNotify('...INFO: Input already defined as a "cbg": copying to Output') ; mttWriteNewLine ; mttWriteNewLine ; cbg = system ; end elapsed_time = mttElapseTime(start_time) ; cpu_utilisation = round(100*elapsed_time.cpu/elapsed_time.clock) ; mttWriteNewLine ; mttNotify(['Completed in ',num2str(elapsed_time.clock),' seconds']) ; mttNotify([' (',num2str(cpu_utilisation),'%% cpu)']) ; mttWriteNewLine ; mttWriteNewLine ; |
Added mttroot/ntt/bin/make_env.m version [bd8ec0bc89].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | function make_env(system) global mtt_environment start_time = mttGetTime ; input = [] ; env = [] ; switch class(system) case 'char', input = 'spec' ; case 'struct', if isfield(system,'representation') input = system.representation ; end end if strcmp(input,'spec') mttWriteNewLine ; mttNotify('Making "env" representation') ; mttWriteNewLine ; env = mttCreateEnvironment(system) ; input = 'env' ; end mttAssert(strcmp(input,'env'),'Input representation not recognised') ; if isempty(env) mttWriteNewLine ; mttNotify('Copying "env" representation') ; mttWriteNewLine ; mttNotify('...INFO: Input already defined as a "env": copying to Output') ; mttWriteNewLine ; mttWriteNewLine ; env = system ; end elapsed_time = mttElapseTime(start_time) ; cpu_utilisation = round(100*elapsed_time.cpu/elapsed_time.clock) ; mttWriteNewLine ; mttNotify(['Completed in ',num2str(elapsed_time.clock),' seconds']) ; mttNotify([' (',num2str(cpu_utilisation),'%% cpu)']) ; mttWriteNewLine ; mttWriteNewLine ; mtt_environment = env ; |
Added mttroot/ntt/bin/make_ese.m version [2b8c245d06].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 | function ese = make_ese(system,sorter_on) global mtt_environment if nargin<2 sorter_on = 1 ; end switch class(system) case 'char', input = 'spec' ; case 'struct', if isfield(system,'representation') input = system.representation ; end end start_time = mttGetTime ; abg = [] ; cbg = [] ; ese = [] ; if strcmp(input,'spec') mttWriteNewLine ; mttNotify('Making "abg" representation') ; mttWriteNewLine ; if isempty(mtt_environment) mttNotify('...WARNING: No "env" definition => all domain references will be ignored') ; mttWriteNewLine ; mttNotify(' => paths will not be recognised') ; mttWriteNewLine ; end abg = mttCreateAcausalBondgraph(system) ; input = 'abg' ; end if strcmp(input,'abg') if isempty(abg) abg = system ; end mttWriteNewLine ; mttNotify('Transforming from "abg" to "cbg"') ; mttWriteNewLine ; cbg = mttCreateCausalBondgraph(abg) ; input = 'cbg' ; end if strcmp(input,'cbg') if isempty(cbg) cbg = system ; end mttWriteNewLine ; mttNotify('Transforming from "cbg" to "ese"') ; mttWriteNewLine ; ese = mttCreateElementaryEquations(cbg,sorter_on) ; input = 'ese' ; end mttAssert(strcmp(input,'ese'),'Input representation not recognised') ; if isempty(ese) mttWriteNewLine ; mttNotify('Making "ese" representation') ; mttWriteNewLine ; mttNotify('Input already defined as a "ese": copying to Output') ; mttWriteNewLine ; mttWriteNewLine ; ese = system ; end elapsed_time = mttElapseTime(start_time) ; cpu_utilisation = round(100*elapsed_time.cpu/elapsed_time.clock) ; mttWriteNewLine ; mttNotify(['Completed in ',num2str(elapsed_time.clock),' seconds']) ; mttNotify([' (',num2str(cpu_utilisation),'%% cpu)']) ; mttWriteNewLine ; mttWriteNewLine ; |
Added mttroot/ntt/bin/make_mdl.m version [8f904e7563].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | function make_sfun(system,sorter_on) global mtt_environment if nargin<2 sorter_on = 1 ; end switch class(system) case 'char', input = 'spec' ; case 'struct', if isfield(system,'representation') input = system.representation ; end end start_time = mttGetTime ; abg = [] ; cbg = [] ; ese = [] ; if strcmp(input,'spec') mttWriteNewLine ; mttNotify('Making "abg" representation') ; mttWriteNewLine ; if isempty(mtt_environment) mttNotify('...WARNING: No "env" definition => all domain references will be ignored') ; mttWriteNewLine ; mttNotify(' => paths will not be recognised') ; mttWriteNewLine ; end abg = mttCreateAcausalBondgraph(system) ; input = 'abg' ; end if strcmp(input,'abg') if isempty(abg) abg = system ; end mttWriteNewLine ; mttNotify('Transforming from "abg" to "cbg"') ; mttWriteNewLine ; cbg = mttCreateCausalBondgraph(abg) ; input = 'cbg' ; end if strcmp(input,'cbg') if isempty(cbg) cbg = system ; end mttWriteNewLine ; mttNotify('Transforming from "cbg" to "ese"') ; mttWriteNewLine ; ese = mttCreateElementaryEquations(cbg,sorter_on) ; input = 'ese' ; end mttAssert(strcmp(input,'ese'),'Input representation not recognised') ; if isempty(ese) ese = system ; end mttCreateSystemMdl(ese) ; elapsed_time = mttElapseTime(start_time) ; cpu_utilisation = round(100*elapsed_time.cpu/elapsed_time.clock) ; mttWriteNewLine ; mttNotify(['Completed in ',num2str(elapsed_time.clock),' seconds']) ; mttNotify([' (',num2str(cpu_utilisation),'%% cpu)']) ; mttWriteNewLine ; mttWriteNewLine ; |
Added mttroot/ntt/bin/make_sfun.m version [9b2b6d6f69].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 | function make_sfun(system,sorter_on) global mtt_environment if nargin<2 sorter_on = 1 ; end switch class(system) case 'char', input = 'spec' ; case 'struct', if isfield(system,'representation') input = system.representation ; end end start_time = mttGetTime ; abg = [] ; cbg = [] ; ese = [] ; if strcmp(input,'spec') mttWriteNewLine ; mttNotify('Making "abg" representation') ; mttWriteNewLine ; if isempty(mtt_environment) mttNotify('...WARNING: No "env" definition => all domain references will be ignored') ; mttWriteNewLine ; mttNotify(' => paths will not be recognised') ; mttWriteNewLine ; end abg = mttCreateAcausalBondgraph(system) ; input = 'abg' ; end if strcmp(input,'abg') if isempty(abg) abg = system ; end mttWriteNewLine ; mttNotify('Transforming from "abg" to "cbg"') ; mttWriteNewLine ; cbg = mttCreateCausalBondgraph(abg) ; input = 'cbg' ; end if strcmp(input,'cbg') if isempty(cbg) cbg = system ; end mttWriteNewLine ; mttNotify('Transforming from "cbg" to "ese"') ; mttWriteNewLine ; ese = mttCreateElementaryEquations(cbg,sorter_on) ; input = 'ese' ; end mttAssert(strcmp(input,'ese'),'Input representation not recognised') ; if isempty(ese) ese = system ; end mttWriteSystemEquations(ese) ; mttWriteSystemDefinitions(ese) ; mttWriteSystemInitialisation(ese) ; mttWriteSystemMapping(ese) ; ese = mttCreateApps(ese) ; mttWriteSystemApps(ese) ; mttWriteSystemSfun(ese) ; elapsed_time = mttElapseTime(start_time) ; cpu_utilisation = round(100*elapsed_time.cpu/elapsed_time.clock) ; mttWriteNewLine ; mttNotify(['Completed in ',num2str(elapsed_time.clock),' seconds']) ; mttNotify([' (',num2str(cpu_utilisation),'%% cpu)']) ; mttWriteNewLine ; mttWriteNewLine ; |
Added mttroot/ntt/bin/trans/m/mttApplyInterfaceCausality.m version [028f9372f5].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 | function model = mttApplyInterfaceCausality(model,specified_rule,branch) ; is_root_model = (nargin==2) ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; if isfield(object,'obj') if is_root_model branch = object_name ; else branch = [branch,'/',object_name] ; end object = mttApplyInterfaceCausality(object,specified_rule,branch) ; model = setfield(model,'obj',object_name,object) ; else if ~isempty(object.cr) if is_root_model branch = mttDetachText(model.source,'/') ; end here = [branch,':',object_name] ; port_names = mttGetFieldNames(object.cr.interface,'port') ; for j = 1:length(port_names) port_name = port_names{j} ; port = getfield(object.cr.interface,'port',port_name) ; inbond = port.in ; outbond = port.out ; for k = 1:mttGetFieldLength(port,'causality') rule = port.causality(k).rule ; definition = port.causality(k).def ; association = port.causality(k).with ; not_applied = ~port.causality(k).applied ; switch rule case 'assert', is_assertion = 1 ; case 'prefer', is_assertion = 0 ; otherwise error(['Unrecognised rule "',port_causality.rule,'" in ',here]) ; end apply_rule = strcmp(specified_rule,rule) & not_applied ; if apply_rule switch definition % case 'effort_state', % mttAssert(mttIsEqual(port.is_flow_state,0),... % ['Attempt to overwrite state assignment at port "',port_name,'" in ',here]) ; % port.is_effort_state = 1 ; % case 'flow_state', % mttAssert(mttIsEqual(port.is_effort_state,0),... % ['Attempt to overwrite state assignment at port "',port_name,'" in ',here]) ; % port.is_flow_state = 1 ; case {'effort_in_flow_out','flow_in_effort_out','flow_out_effort_in','effort_out_flow_in'} mttAssert(isempty(association),... ['Over-constraint at port "',port_name,'" in ',here]) ; switch definition case {'effort_in_flow_out','flow_out_effort_in'}, [model,inbond_ok] = mttUpdateBondCausality(model,inbond,1,1,1) ; [model,outbond_ok] = mttUpdateBondCausality(model,outbond,0,0,1) ; case {'flow_in_effort_out','effort_out_flow_in'}, [model,inbond_ok] = mttUpdateBondCausality(model,inbond,0,0,1) ; [model,outbond_ok] = mttUpdateBondCausality(model,outbond,1,1,1) ; end ok = inbond_ok & outbond_ok ; if is_assertion mttAssert(ok,['Causal conflict at port "',port_name,'" in ',here]) ; end case 'effort_in' mttAssert(isempty(association),... ['Over-constraint at port "',port_name,'" in ',here]) ; [model,inbond_ok] = mttUpdateBondCausality(model,inbond,1,[],1) ; [model,outbond_ok] = mttUpdateBondCausality(model,outbond,0,[],1) ; ok = inbond_ok & outbond_ok ; if is_assertion mttAssert(ok,['Causal conflict at port "',port_name,'" in ',here]) ; end case 'effort_out' mttAssert(isempty(association),... ['Over-constraint at port "',port_name,'" in ',here]) ; [model,inbond_ok] = mttUpdateBondCausality(model,inbond,0,[],1) ; [model,outbond_ok] = mttUpdateBondCausality(model,outbond,1,[],1) ; ok = inbond_ok & outbond_ok ; if is_assertion mttAssert(ok,['Causal conflict at port "',port_name,'" in ',here]) ; end case 'flow_in' mttAssert(isempty(association),... ['Over-constraint at port "',port_name,'" in ',here]) ; [model,inbond_ok] = mttUpdateBondCausality(model,inbond,[],0,1) ; [model,outbond_ok] = mttUpdateBondCausality(model,outbond,[],1,1) ; ok = inbond_ok & outbond_ok ; if is_assertion mttAssert(ok,['Causal conflict at port "',port_name,'" in ',here]) ; end case 'flow_out' mttAssert(isempty(association),... ['Over-constraint at port "',port_name,'" in ',here]) ; [model,inbond_ok] = mttUpdateBondCausality(model,inbond,[],1,1) ; [model,outbond_ok] = mttUpdateBondCausality(model,outbond,[],0,1) ; ok = inbond_ok & outbond_ok ; if is_assertion mttAssert(ok,['Causal conflict at port "',port_name,'" in ',here]) ; end case 'unicausal', mttAssert(isempty(association),... ['Over-constraint at port "',port_name,'" in ',here]) ; [model,inbond_ok] = mttUpdateBondCausality(model,inbond,[],[],1) ; [model,outbond_ok] = mttUpdateBondCausality(model,outbond,[],[],1) ; ok = inbond_ok & outbond_ok ; if is_assertion mttAssert(ok,['Causal conflict at port "',port_name,'" in ',here]) ; end case {'equicausal','anticausal'} mttAssert(length(association)==1,... ['Incorrect constraint at port "',port_name,'" in ',here]) ; associated_port_name = association{1} ; associated_port = getfield(cr.interface,'port',associated_port_name) ; associated_inbond = associated_port.in ; associated_outbond = associated_port.out ; mttAsert(xor(isempty(inbond),isempty(outbond)),... ['Causal rule expects unique bond at port "',port_name,'" in ',here]) ; mttAsert(xor(isempty(associated_inbond),isempty(associated_outbond)),... ['Causal rule expects unique bond at port "',associated_port_name,'" in ',here]) ; if isempty(associated_inbond) a = associated_outbond ; else a = associated_inbond ; end if isempty(inbond) b = outbond ; else b = inbond ; end switch definition case 'equicausal', [model,bond_ok] = mttUpdateBondCausality(model,b,... model.bond(a).effort,model.bond(a).flow,model.bond(a).unicausal) ; [model,associated_bond_ok] = mttUpdateBondCausality(model,a,... model.bond(b).effort,~model.bond(b).flow,model.bond(b).unicausal) ; case 'anticausal', [model,bond_ok] = mttUpdateBondCausality(model,b,... ~model.bond(a).effort,model.bond(a).flow,model.bond(a).unicausal) ; [model,associated_bond_ok] = mttUpdateBondCausality(model,a,... ~model.bond(b).effort,~model.bond(b).flow,model.bond(b).unicausal) ; end ok = bond_ok & associated_bond_ok ; if is_assertion mttAssert(ok,['Causal conflict between ports "',port_name,... 'and',associated_port_name,'" in ',here]) ; end otherwise, error(['Unrecognised constraint "',definition,'" in ',here]) ; end port.causality(k).applied = 1 ; object = setfield(object,'cr','interface','port',port_name,port) ; model = setfield(model,'obj',object_name,object) ; end end end end end end |
Added mttroot/ntt/bin/trans/m/mttApplyInterfaceDomains.m version [bfc53eba3d].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | function model = mttApplyInterfaceDomains(model,branch) ; is_root_model = (nargin==1) ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; if isfield(object,'obj') if is_root_model branch = object_name ; else branch = [branch,'/',object_name] ; end object = mttApplyInterfaceDomains(object,branch) ; model = setfield(model,'obj',object_name,object) ; else if ~isempty(object.cr) if is_root_model branch = mttDetachText(model.source,'/') ; end here = [branch,':',object_name] ; port_names = mttGetFieldNames(object.cr.interface,'port') ; for j = 1:length(port_names) port_name = port_names{j} ; port = getfield(object.cr.interface,'port',port_name) ; predefined_domain = port.domain ; predefined_domain_item = port.domain_item ; inbond = port.in ; outbond = port.out ; if isempty(inbond) bond_number = outbond ; else bond_number = inbond ; end [model,ok] = mttUpdateBondDomain(model,bond_number,predefined_domain,predefined_domain_item) ; mttAssert(ok,['Domain conflict at port "',port_name,'" in ',here]) ; end end end end |
Added mttroot/ntt/bin/trans/m/mttCreateAcausalBondgraph.m version [a4799dbea4].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | function model = mttCreateAcausalBondgraph(system,root) global mtt_environment switch nargin case 0, model = [] ; return ; case 1, root = [] ; is_root_model = 1 ; otherwise, is_root_model = 0 ; end if is_root_model model = intialise_model(system) ; directory_name = identify_directory_name(system) ; source_name = identify_source_name(system,directory_name) ; mttNotify('...acquiring "abg" source definitions') ; mttWriteNewLine ; else model = propagate_root_data(root) ; source_name = system ; end specification_filename = [source_name,'_abg.txt'] ; specification = mttFetchSpecification(specification_filename) ; specification = mttSetFieldDefault(specification,'bondgraph',system) ; [local_system_name,rubbish] = mttDetachText(system,'/') ; if isempty(local_system_name) local_system_name = system ; end if is_root_model source_name = identify_source_name(specification.bondgraph,directory_name) ; else source_name = specification.bondgraph ; end source_name = mttCutText(source_name,'_abg.fig') ; bondgraph_filename = [source_name,'_abg.fig'] ; bondgraph = mttFetchBondgraph(bondgraph_filename) ; model = mttCreateUnifiedModel(model,bondgraph,specification) ; model = mttDeleteField(model,'branch') ; model = mttDeleteField(model,'leaf') ; if is_root_model mttWriteNewLine ; mttNotify('...acquiring "cr" source definitions') ; mttWriteNewLine ; for n = 1:length(model.crs) source_name = model.crs{n} ; cr_filename = [source_name,'_cr.txt'] ; if ~mttFileExists(cr_filename) cr_short_name = mttDetachText(source_name,'/') ; mttNotify([' ...ERROR: "',cr_short_name,'_cr" source does not exist']) ; mttWriteNewLine ; mttNotify([' ...finding dependencies for ',source_name,':']) ; mttWriteNewLine ; prefix = mttDetachText(system,'/') ; if isempty(prefix) prefix = system ; end cr_user = model.cr_usage(n).obj ; for i = 1:length(cr_user) mttNotify([' ',prefix,'/',cr_user{i}]) ; mttWriteNewLine ; end end model.cr(n) = mttFetchInterfaceDefinition(cr_filename) ; end model = mttDeleteField(model,'cr_usage') ; model = mttDeleteField(model,'crs') ; model = mttDeleteField(model,'abgs') ; end model.env = mtt_environment ; function model = intialise_model(system) model.representation = 'abg' ; model.abgs = [] ; model.crs = [] ; model.cr_usage = [] ; model.branch = [] ; model.leaf = [] ; function model = propagate_root_data(root) model.abgs = root.abgs ; model.crs = root.crs ; model.cr_usage = root.cr_usage ; model.branch = root.branch ; model.leaf = root.leaf ; function directory = identify_directory_name(system) mttAssert(ischar(system),'System must be specified by name') ; working_directory = pwd ; working_directory = strrep(working_directory,'\','/') ; [system_name,local_directory] = mttDetachText(system,'/') ; if isempty(system_name) local_directory = [] ; end if isempty(local_directory) directory = working_directory ; else directory = mttLocateDirectory(working_directory,local_directory) ; end function source = identify_source_name(system,directory) [system_name,local_directory] = mttDetachText(system,'/') ; if isempty(system_name) system_name = system ; local_directory = [] ; end source = [directory,'/',system_name] ; |
Added mttroot/ntt/bin/trans/m/mttCreateApps.m version [dd7bd6b560].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 | function model = mttCreateApps(model) apps_filename = [model.source,'_apps.txt'] ; apps = mttFetchApps(apps_filename) ; if isempty(apps) return ; end for i = 1:length(apps.app) app_source = apps.app{i} ; [rubbish,working_directory] = mttDetachText(model.source,'/') ; [name,path_spec] = mttDetachText(app_source,'/') ; if isempty(name) source_name = [working_directory,'/',domain_source] ; else directory = identify_directory(working_directory,path_spec,model) ; source_name = [directory,'/',name] ; end app_filename = [source_name,'_app.h'] ; model.app{i} = app_filename ; end function directory = identify_directory(working_directory,path_spec,model) path_names = mttGetFieldNames(model.env,'path') ; if isempty(path_spec) directory = [] ; else if path_spec(1)=='$' [path_alias,path_branch] = mttCutText(path_spec,'/') ; path_alias(1) = [] ; mttAssert(ismember(path_alias,path_names),... ['Path "',path_alias,'" not recognised']) ; path_root = getfield(model.env,'path',path_alias) ; if isempty(path_branch) directory = path_root ; else directory = [path_root,'/',path_branch] ; end else [name,local_directory] = mttDetachText(path_spec,'/') ; directory_located = 0 ; if strcmp(local_directory,'.') if isempty(name) directory = working_directory ; directory_located = 1 ; else local_directory = name ; end else local_directory = path_spec ; end if ~directory_located directory = mttLocateDirectory(working_directory,local_directory) ; end end end |
Added mttroot/ntt/bin/trans/m/mttCreateCausalBondgraph.m version [88053c538d].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 | function model = mttCreateCausalBondgraph(model) model.representation = 'cbg' ; model = incorporate_interface_definitions(model) ; model = establish_abg_dependencies(model) ; model = create_object_hierarchy(model) ; model = assign_sympar_values(model) ; model = complete_causal_assignment(model) ; model = complete_domain_assignment(model) ; model = overwrite_implicit_domains(model) ; function model = incorporate_interface_definitions(model) mttNotify('...incorporating "cr" definitions') ; mttWriteNewLine ; mttNotify([' ...processing ',model.source]) ; mttWriteNewLine ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; if ~mttIsFoundationClass(object.class) mttAssert(xor(isempty(object.abg),isempty(object.cr)),... ['"',object_name,'" must exclusively have a "cr" or an "abg" representation']) ; end if isempty(object.cr) object = mttDeleteField(object,'cr_item') ; model = setfield(model,'obj',object_name,object) ; else model = mttEmbedInterfaceDefinition(model,object_name) ; end end for i = 1:mttGetFieldLength(model,'abg') component_type = mttDetachText(model.abg(i).source,'/') ; mttNotify([' ...processing "#',num2str(i),':',component_type,'" ',model.abg(i).source]) ; mttWriteNewLine ; objects = mttGetFieldNames(model.abg(i),'obj') ; for j = 1:length(objects) object_name = objects{j} ; object = getfield(model,'abg',{i},'obj',object_name) ; if ~mttIsFoundationClass(object.class) mttAssert(xor(isempty(object.abg),isempty(object.cr)),... ['abg[',num2str(i),']: "',object_name,'" must exclusively have a "cr" or an "abg" representation']) ; end if isempty(object.cr) object = mttDeleteField(object,'cr_item') ; model = setfield(model,'abg',{i},'obj',object_name,object) ; else model.abg(i) = mttEmbedInterfaceDefinition(model.abg(i),object_name,model) ; end end model.abg(i).invokes = [] ; model.abg(i).invoked_by = [] ; end model = mttDeleteField(model,'cr') ; function model = establish_abg_dependencies(model) mttNotify('...establishing "abg" dependencies') ; mttWriteNewLine ; for i = 1:mttGetFieldLength(model,'abg') objects = mttGetFieldNames(model.abg(i),'obj') ; for j = 1:length(objects) object_name = objects{j} ; object = getfield(model.abg(i).obj,object_name) ; if isempty(object.cr) %... still within object hierarchy if ~mttIsFoundationClass(object.class) existing_dependencies = model.abg(i).invokes ; if isempty(existing_dependencies) new_dependency = 1 ; else new_dependency = isempty(find(existing_dependencies==object.abg)) ; end if new_dependency model.abg(i).invokes = [existing_dependencies,object.abg] ; end existing_dependencies = model.abg(object.abg).invoked_by ; if isempty(existing_dependencies) new_dependency = 1 ; else new_dependency = isempty(find(existing_dependencies==i)) ; end if new_dependency model.abg(object.abg).invoked_by = [existing_dependencies,i] ; end end end end end model.invokes = [] ; objects = mttGetFieldNames(model,'obj') ; for j = 1:length(objects) object_name = objects{j} ; object = getfield(model.obj,object_name) ; if ~isempty(object.abg) if ~mttIsFoundationClass(object.class) existing_dependencies = model.invokes ; if isempty(existing_dependencies) new_dependency = 1 ; else new_dependency = isempty(find(existing_dependencies==object.abg)) ; end if new_dependency model.invokes = [existing_dependencies,object.abg] ; end end end end function model = create_object_hierarchy(model) ; mttNotify('...creating object hierarchy') ; mttWriteNewLine ; top_level_model = mttDetachText(model.source,'/') ; if isfield(model,'abg') is_embedded = zeros(1,length(model.abg)) ; embedding = 1 ; else embedding = 0 ; end component = 0 ; embedding = isfield(model,'abg') ; while embedding component = 1 + mod(component,length(model.abg)) ; if ~is_embedded(component) if isempty(model.abg(component).invokes) number_of_systems = length(model.abg(component).invoked_by) ; for n = 1:number_of_systems system = model.abg(component).invoked_by(n) ; component_type = mttDetachText(model.abg(component).source,'/') ; system_type = mttDetachText(model.abg(system).source,'/') ; mttNotify([' ...embedding "#',num2str(component),':',component_type,... '" definition within "#',num2str(system),':',system_type,'" objects']) ; mttWriteNewLine ; model = mttEmbedAcausalBondgraph(model,component,system) ; end model.abg(component).invoked_by = [] ; if ~isempty(find(model.invokes==component)) component_type = mttDetachText(model.abg(component).source,'/') ; mttNotify([' ...embedding "#',num2str(component),':',component_type,... '" definition within "',top_level_model,'"']) ; mttWriteNewLine ; model = mttEmbedAcausalBondgraph(model,component) ; end is_embedded(component) = 1 ; end end embedding = any(~is_embedded) ; end model = mttDeleteField(model,'abg') ; model = mttDeleteField(model,'invokes') ; function model = assign_sympar_values(model) mttNotify('...assigning "sympar" values') ; mttWriteNewLine ; model_name = mttDetachText(model.source,'/') ; current_branch = model_name ; sympars = model.sympar ; defaults = model.sympar_default ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; if ~mttIsPassiveClass(object.class) for j = 1:length(object.parameter) object_parameter = object.parameter{j} ; if ischar(object_parameter) index = strmatch(object_parameter,sympars,'exact') ; new_parameter = 0 ; if isempty(index) new_parameter = 1 ; else default_value = defaults{index} ; if isempty(default_value) new_parameter = 1 ; else object.parameter{j} = default_value ; end end if new_parameter object.parameter{j} = [current_branch,'___',object_parameter] ; end end end branch = [model_name,'__',object_name] ; object = assign_object_sympar_values(object,branch) ; model = setfield(model,'obj',object_name,object) ; end end function model = assign_object_sympar_values(model,branch) current_branch = branch ; sympars = model.sympar ; parameters = model.parameter ; if ~isempty(model.abg) objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; if ~mttIsPassiveClass(object.class) for j = 1:length(object.parameter) object_parameter = object.parameter{j} ; if ischar(object_parameter) index = strmatch(object_parameter,sympars,'exact') ; if isempty(index) object.parameter{j} = [current_branch,'___',object_parameter] ; else object.parameter{j} = parameters{index} ; end end end branch = [current_branch,'__',object_name] ; object = assign_object_sympar_values(object,branch) ; model = setfield(model,'obj',object_name,object) ; end end elseif ~isempty(model.cr) model.cr.parameter = model.parameter ; end function model = complete_causal_assignment(model) mttWriteNewLine ; mttNotify('...summarising model content') ; mttWriteNewLine ; model = mttCountObjects(model) ; mttNotifyNumberOfObjects(model) ; mttWriteNewLine ; model = mttDeleteField(model,'count') ; model = mttMeasureCausalCompletion(model) ; mttNotifyNumberOfBonds(model) ; mttWriteNewLine ; mttWriteNewLine ; mttNotify('...analysing predefined causality') ; mttWriteNewLine ; mttNotifyCausalCompletion(model) ; mttWriteNewLine ; if model.causal_completion.is_causal mttNotify('...applying CR constraints') ; mttWriteNewLine ; model = incorporate_cr_rules(model,'assert') ; else mttNotify('...completing causality') ; mttWriteNewLine ; iterations = 0 ; propagating = 1 ; while propagating iterations = iterations + 1 ; previous_causal_completion = model.causal_completion ; model = mttApplyInterfaceCausality(model,'assert') ; model = mttPropagateCausality(model) ; model = mttApplyInterfaceCausality(model,'prefer') ; model = mttPropagateCausality(model) ; model = mttMeasureCausalCompletion(model) ; is_stable = mttCompareCausalCompletion(model.causal_completion,previous_causal_completion) ; propagating = (~is_stable) ; if propagating mttNotify(['...iteration ',num2str(iterations)]) ; mttWriteNewLine ; mttNotifyCausalCompletion(model) ; end propagating = propagating & (~model.causal_completion.is_causal) ; end end if ~model.causal_completion.is_causal mttWriteNewLine ; mttNotify('...causality not complete') ; mttWriteNewLine ; mttWriteNewLine ; mttIdentifyUndercausalBonds(model) ; end model = mttDeleteField(model,'causal_completion') ; function model = complete_domain_assignment(model) mttWriteNewLine ; mttNotify('...allocating domain definitions') ; mttWriteNewLine ; model = mttMeasureDomainCompletion(model) ; iterations = 0 ; propagating = 1 ; while propagating iterations = iterations + 1 ; previous_domain_completion = model.domain_completion ; model = mttApplyInterfaceDomains(model) ; model = mttPropagateDomains(model) ; model = mttMeasureDomainCompletion(model) ; is_stable = mttCompareDomainCompletion(model.domain_completion,previous_domain_completion) ; propagating = (~is_stable) ; if propagating mttNotify(['...iteration ',num2str(iterations)]) ; mttWriteNewLine ; mttNotifyDomainCompletion(model) ; end propagating = propagating & (~model.domain_completion.is_done) ; end model = mttDeleteField(model,'domain_completion') ; function model = overwrite_implicit_domains(model) mttWriteNewLine ; mttNotify('...overwriting implicit domain definitions') ; mttWriteNewLine ; model = mttOverwriteImplicitDomains(model) ; function model = mttOverwriteImplicitDomains(root,model,env) is_root_model = nargin==1 ; if is_root_model model = root ; env = root.env ; end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; if ~isempty(object.abg) object = mttOverwriteImplicitDomains(model,object,env) ; end if ~isempty(object.cr) interface_ports = mttGetFieldNames(object.cr.interface,'port') ; for j = 1:length(interface_ports) port_name = interface_ports{j} ; port = getfield(object.cr.interface,'port',port_name) ; if isempty(port.domain) if isempty(port.in) bond_number = port.out ; else bond_number = port.in ; end actual_domain = model.bond(bond_number).domain ; actual_domain_item = model.bond(bond_number).domain_item ; port.domain = actual_domain ; port.domain_item = actual_domain_item ; object.cr.interface = setfield(object.cr.interface,'port',port_name,port) ; number_of_operators = mttGetFieldLength(object.cr,'operator') ; for op_counter = 1:number_of_operators operator = object.cr.operator(op_counter) ; matching_links = strmatch(port_name,{operator.link.name},'exact') ; number_of_equations = mttGetFieldLength(operator,'equation') ; for eq_counter = 1:number_of_equations equation = operator.equation(eq_counter) ; % if isempty(equation.domain) number_of_chunks = mttGetFieldLength(equation,'chunk') ; for chunk_counter = 1:number_of_chunks chunk = equation.chunk{chunk_counter} ; if iscell(chunk) if strcmp(chunk{1},'link') link = chunk{2} ; if any(link==matching_links) covar = chunk{3} ; chunk{3} = ['generic___',covar] ; end end equation.chunk{chunk_counter} = chunk ; end end operator.equation(eq_counter) = equation ; % end end object.cr.operator(op_counter) = operator ; end end end end model = setfield(model,'obj',object_name,object) ; end |
Added mttroot/ntt/bin/trans/m/mttCreateElementaryEquations.m version [170ccc2756].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 | function model = mttCreateElementaryEquations(model,sorter_on) model.representation = 'ese' ; [model,ese,namelist] = specify_equations(model) ; if sorter_on [sse,counter] = sort_equations(ese,model,namelist) ; else sse = ese ; counter = 0 ; end model.equation = sse ; model.sorted_equations = counter ; model.namelist = namelist ; function [model,ese,namelist] = specify_equations(model,branch,root_namelist) is_root_model = (nargin==1) ; if is_root_model mttNotify('...specifying equations') ; mttWriteNewLine ; branch = mttDetachText(model.source,'/') ; name_counter = 1 ; namelist(name_counter).var = '0' ; namelist(name_counter).domain = [] ; namelist(name_counter).domain_item = [] ; else namelist = root_namelist ; name_counter = length(namelist) ; end mttNotify([' ...processing ',branch]) ; mttWriteNewLine ; objects = mttGetFieldNames(model,'obj') ; line = 0 ; for n = 1:length(objects) object_name = objects{n} ; object = getfield(model,'obj',object_name) ; here = [branch,':',object_name] ; switch object.class case {'SS','Se','Sf','De','Df'}, for j = 1:mttGetFieldLength(object,'interface') flow_equation = [] ; effort_equation = [] ; terminal = [branch,'__',object_name] ; inbond = object.interface(j).in ; outbond = object.interface(j).out ; if ~isempty(inbond) bond = model.bond(inbond) ; [specified_domain,specified_domain_item] = mttGetBondDomain(model,inbond) ; new_name = 0 ; line = line + 1 ; if bond.flow if strcmp(object.class,'De') ese(line) = specify_ese(branch,[2*inbond],branch,{1},[]) ; else ese(line) = specify_ese(branch,[2*inbond],branch,{name_counter+1},[]) ; new_name = 1 ; end else ese(line) = specify_ese(branch,{name_counter+1},branch,[2*inbond],[]) ; new_name = 1 ; end if new_name name_counter = name_counter + 1 ; namelist(name_counter).var = [terminal,'.flow'] ; namelist(name_counter).domain = specified_domain ; namelist(name_counter).domain_item = specified_domain_item ; end new_name = 0 ; line = line + 1 ; if bond.effort ese(line) = specify_ese(branch,{name_counter+1},branch,[2*inbond-1],[]) ; new_name = 1 ; else if strcmp(object.class,'Df') ese(line) = specify_ese(branch,[2*inbond-1],branch,{1},[]) ; else ese(line) = specify_ese(branch,[2*inbond-1],branch,{name_counter+1},[]) ; new_name = 1 ; end end if new_name name_counter = name_counter + 1 ; namelist(name_counter).var = [terminal,'.effort'] ; namelist(name_counter).domain = specified_domain ; namelist(name_counter).domain_item = specified_domain_item ; end end if ~isempty(outbond) bond = model.bond(outbond) ; [specified_domain,specified_domain_item] = mttGetBondDomain(model,outbond) ; new_name = 0 ; if bond.flow if ~strcmp(object.class,'Se') line = line + 1 ; ese(line) = specify_ese(branch,{name_counter+1},branch,[2*outbond],[]) ; new_name = 1 ; end else line = line + 1 ; ese(line) = specify_ese(branch,[2*outbond],branch,{name_counter+1},[]) ; new_name = 1 ; end if new_name name_counter = name_counter + 1 ; namelist(name_counter).var = [terminal,'.flow'] ; namelist(name_counter).domain = specified_domain ; namelist(name_counter).domain_item = specified_domain_item ; end new_name = 0 ; if bond.effort line = line + 1 ; ese(line) = specify_ese(branch,[2*outbond-1],branch,{name_counter+1},[]) ; new_name = 1 ; else if ~strcmp(object.class,'Sf') line = line + 1 ; ese(line) = specify_ese(branch,{name_counter+1},branch,[2*outbond-1],[]) ; new_name = 1 ; end end if new_name name_counter = name_counter + 1 ; namelist(name_counter).var = [terminal,'.effort'] ; namelist(name_counter).domain = specified_domain ; namelist(name_counter).domain_item = specified_domain_item ; end end end case '0', imposed_effort = [] ; resultant_flow = [] ; for i = 1:mttGetFieldLength(object,'interface') inbond = object.interface(i).in ; outbond = object.interface(i).out ; if isempty(inbond) bond_number(i) = outbond ; orientation(i) = 0 ; else bond_number(i) = inbond ; orientation(i) = 1 ; end [effort,flow] = mttGetBondCausality(model,bond_number(i)) ; if effort==orientation(i) imposed_effort = 2*bond_number(i)-1 ; end if flow==orientation(i) resultant_flow = 2*bond_number(i) ; resultant_orientation = orientation(i) ; end end for i = 1:mttGetFieldLength(object,'interface') effort = 2*bond_number(i)-1 ; if effort~=imposed_effort derived_effort = effort ; line = line + 1 ; ese(line) = specify_ese(branch,derived_effort,branch,imposed_effort,[]) ; end end flow_summation = [] ; for i = 1:mttGetFieldLength(object,'interface') flow = 2*bond_number(i) ; if flow~=resultant_flow impinging_flow = flow ; if orientation(i) if resultant_orientation flow_summation = [ flow_summation, -impinging_flow ] ; else flow_summation = [ flow_summation, impinging_flow ] ; end else if resultant_orientation flow_summation = [ flow_summation, impinging_flow ] ; else flow_summation = [ flow_summation, -impinging_flow ] ; end end end end line = line + 1 ; ese(line) = specify_ese(branch,resultant_flow,branch,flow_summation,[]) ; case '1', imposed_flow = [] ; resultant_effort = [] ; for i = 1:mttGetFieldLength(object,'interface') inbond = object.interface(i).in ; outbond = object.interface(i).out ; if isempty(inbond) bond_number(i) = outbond ; orientation(i) = 0 ; else bond_number(i) = inbond ; orientation(i) = 1 ; end [effort,flow] = mttGetBondCausality(model,bond_number(i)) ; if flow~=orientation(i) imposed_flow = 2*bond_number(i) ; end if effort~=orientation(i) resultant_effort = 2*bond_number(i)-1 ; resultant_orientation = orientation(i) ; end end for i = 1:mttGetFieldLength(object,'interface') flow = 2*bond_number(i) ; if flow~=imposed_flow derived_flow = flow ; line = line + 1 ; ese(line) = specify_ese(branch,derived_flow,branch,imposed_flow,[]) ; end end effort_summation = [] ; for i = 1:mttGetFieldLength(object,'interface') effort = 2*bond_number(i)-1 ; if effort~=resultant_effort impinging_effort = effort ; if orientation(i) if resultant_orientation effort_summation = [ effort_summation, -impinging_effort ] ; else effort_summation = [ effort_summation, impinging_effort ] ; end else if resultant_orientation effort_summation = [ effort_summation, impinging_effort ] ; else effort_summation = [ effort_summation, -impinging_effort ] ; end end end end line = line + 1 ; ese(line) = specify_ese(branch,resultant_effort,branch,effort_summation,[]) ; otherwise, if ~isempty(object.cr) interface = object.cr.interface ; port_names = mttGetFieldNames(interface,'port') ; number_of_ports = length(port_names) ; link_counter = 0 ; for i = 1:number_of_ports port_name = port_names{i} ; port = getfield(interface,'port',port_name) ; terminal = [branch,'__',object_name,'___',port_name] ; inbond = port.in ; outbond = port.out ; if ~isempty(inbond) bond = model.bond(inbond) ; [specified_domain,specified_domain_item] = mttGetBondDomain(model,inbond) ; name_counter = name_counter + 1 ; if port.is_flow_state namelist(name_counter).var = [terminal,'.flow_state'] ; else namelist(name_counter).var = [terminal,'.flow'] ; end namelist(name_counter).domain = specified_domain ; namelist(name_counter).domain_item = specified_domain_item ; line = line + 1 ; link_counter = link_counter + 1 ; if bond.flow ese(line) = specify_ese(branch,[2*inbond],branch,{name_counter},[]) ; link(link_counter) = create_link(0,0,1,port_name,port.is_flow_state) ; else ese(line) = specify_ese(branch,{name_counter},branch,[2*inbond],[]) ; link(link_counter) = create_link(1,0,1,port_name,port.is_flow_state) ; end name_counter = name_counter + 1 ; if port.is_effort_state namelist(name_counter).var = [terminal,'.effort_state'] ; else namelist(name_counter).var = [terminal,'.effort'] ; end namelist(name_counter).domain = specified_domain ; namelist(name_counter).domain_item = specified_domain_item ; line = line + 1 ; link_counter = link_counter + 1 ; if bond.effort ese(line) = specify_ese(branch,{name_counter},branch,[2*inbond-1],[]) ; link(link_counter) = create_link(1,1,0,port_name,port.is_effort_state) ; else ese(line) = specify_ese(branch,[2*inbond-1],branch,{name_counter},[]) ; link(link_counter) = create_link(0,1,0,port_name,port.is_effort_state) ; end end if ~isempty(outbond) bond = model.bond(outbond) ; [specified_domain,specified_domain_item] = mttGetBondDomain(model,outbond) ; name_counter = name_counter + 1 ; if port.is_flow_state namelist(name_counter).var = [terminal,'.flow_state'] ; else namelist(name_counter).var = [terminal,'.flow'] ; end namelist(name_counter).domain = specified_domain ; namelist(name_counter).domain_item = specified_domain_item ; line = line + 1 ; link_counter = link_counter + 1 ; if bond.flow ese(line) = specify_ese(branch,{name_counter},branch,[2*outbond],[]) ; link(link_counter) = create_link(1,0,1,port_name,port.is_flow_state) ; else ese(line) = specify_ese(branch,[2*outbond],branch,{name_counter},[]) ; link(link_counter) = create_link(0,0,1,port_name,port.is_flow_state) ; end name_counter = name_counter + 1 ; if port.is_effort_state namelist(name_counter).var = [terminal,'.effort_state'] ; else namelist(name_counter).var = [terminal,'.effort'] ; end namelist(name_counter).domain = specified_domain ; namelist(name_counter).domain_item = specified_domain_item ; line = line + 1 ; link_counter = link_counter + 1 ; if bond.effort ese(line) = specify_ese(branch,[2*outbond-1],branch,{name_counter},[]) ; link(link_counter) = create_link(0,1,0,port_name,port.is_effort_state) ; else ese(line) = specify_ese(branch,{name_counter},branch,[2*outbond-1],[]) ; link(link_counter) = create_link(1,1,0,port_name,port.is_effort_state) ; end end end input_mask = zeros(number_of_ports,1) ; output_mask = zeros(number_of_ports,1) ; number_of_links = link_counter ; linked = zeros(number_of_links,1) ; operators = object.cr.operator ; number_of_operators = length(operators) ; object.cr.used_operator = zeros(1,number_of_operators) ; op_counter = 0 ; matching = 1 ; while matching op_counter = op_counter + 1 ; operator = operators(op_counter) ; full_operator_name = [branch,'__',object_name,'___',operator.name] ; number_of_op_links = length(operator.link) ; op_linked = zeros(number_of_op_links,1) ; for j = 1:number_of_op_links k = 0 ; comparing = 1 ; while comparing k = k + 1 ; if compare_links(link(k),operator.link(j)) op_linked(j) = k ; comparing = 0 ; end comparing = comparing & (k<number_of_links) ; end end input_counter = 0 ; output_counter = 0 ; input = [] ; output = [] ; if all(op_linked) object.cr.used_operator(op_counter) = 1 ; interface = object.cr.interface ; assigned_ports = mttGetFieldNames(operator,'assign') ; for j = 1:length(assigned_ports) port_name = assigned_ports{j} ; next = getfield(operator.assign,port_name) ; actual_port = getfield(interface,'port',port_name) ; if ~isempty(actual_port.assign) previous = actual_port.assign ; for k = 1:length(next.covar) covar = next.covar{k} ; index = strmatch(covar,previous.covar,'exact') ; if ~isempty(index) mttAssert(strcmp(next.state{k},previous.state{k}),... ['Conflicting state assignments for port "',port_name,'.',covar,'" in ',here]) ; else actual_port.assign.state{index} = next.state{k} ; end end else actual_port.assign = next ; end interface = setfield(interface,'port',port_name,actual_port) ; end % operator = mttDeleteField(operator,'assign') ; % object.cr.operator(op_counter) = operator ; object.cr.interface = interface ; model = setfield(model,'obj',object_name,object) ; for j = 1:number_of_op_links k = op_linked(j) ; linked(k) = 1 ; link(k).is_unconstrained = operator.link(j).is_unconstrained ; current_link = link(k) ; port_name = current_link.name ; port_index = strmatch(port_name,port_names,'exact') ; terminal = [branch,'__',object_name,'___',port_name] ; if current_link.is_effort if current_link.is_state link_name{j} = [terminal,'.effort_state'] ; else link_name{j} = [terminal,'.effort'] ; end end if current_link.is_flow if current_link.is_state link_name{j} = [terminal,'.flow_state'] ; else link_name{j} = [terminal,'.flow'] ; end end matched_name_counter = strmatch(link_name{j},{namelist.var},'exact') ; if current_link.is_input input_mask(port_index) = 1 ; if current_link.is_unconstrained input_counter = input_counter + 1 ; input{input_counter} = matched_name_counter ; end else mttAssert(~output_mask(port_index),... ['Over-determined output "',port_name,'" in operator ',full_operator_name]) ; output_mask(port_index) = 1 ; if current_link.is_unconstrained & ~current_link.is_state output_counter = output_counter + 1 ; output{output_counter} = matched_name_counter ; end end end line = line + 1 ; ese(line) = specify_ese(branch,output,branch,input,full_operator_name) ; for j = 1:number_of_op_links k = op_linked(j) ; current_link = link(k) ; matched_name_counter = strmatch(link_name{j},{namelist.var},'exact') ; if ~current_link.is_input if ~current_link.is_unconstrained line = line + 1 ; ese(line) = specify_ese(branch,{matched_name_counter},branch,{1},[]) ; end end end end unused_inputs = ~all(input_mask) ; unused_outputs = ~all(output_mask) ; still_counting = op_counter<number_of_operators ; matching = (unused_inputs | unused_outputs) & (op_counter<number_of_operators) ; end mttAssert(all(input_mask),... ['Unattached input(s) in "cr" implementation in ',here]) ; mttAssert(all(output_mask),... ['Unattached output(s) in "cr" implementation in ',here]) ; mttAssert(all(linked),... ['Unattached ports in "cr" implementation in ',here]) ; end end end for n = 1:length(objects) object_name = objects{n} ; object = getfield(model,'obj',object_name) ; here = [branch,':',object_name] ; if ~isempty(object.cr) operators = object.cr.operator ; number_of_operators = length(operators) ; object.cr = mttDeleteField(object.cr,'operator') ; used_counter = 0 ; for op_counter = 1:number_of_operators operator = operators(op_counter) ; if object.cr.used_operator(op_counter) used_counter = used_counter + 1 ; used_operator = operator ; % used_operator = mttDeleteField(used_operator,'is_used') ; used_operator = mttDeleteField(used_operator,'assign') ; object.cr.operator(used_counter) = used_operator ; end end end if ~isempty(object.abg) next_branch = [branch,'__',object_name] ; for j = 1:mttGetFieldLength(object,'interface') inbond = object.interface(j).in ; outbond = object.interface(j).out ; inmap = object.interface(j).map.in ; outmap = object.interface(j).map.out ; interface_class = object.interface(j).class ; if ~isempty(inbond) bond = model.bond(inbond) ; line = line + 1 ; if bond.flow if strcmp(interface_class,'Se') ese(line) = specify_ese(branch,[2*inbond],next_branch,{1},[]) ; else ese(line) = specify_ese(branch,[2*inbond],next_branch,[2*inmap],[]) ; end else ese(line) = specify_ese(next_branch,[2*inmap],branch,[2*inbond],[]) ; end line = line + 1 ; if bond.effort ese(line) = specify_ese(next_branch,[2*inmap-1],branch,[2*inbond-1],[]) ; else if strcmp(interface_class,'Sf') ese(line) = specify_ese(branch,[2*inbond-1],next_branch,{1},[]) ; else ese(line) = specify_ese(branch,[2*inbond-1],next_branch,[2*inmap-1],[]) ; end end end if ~isempty(outbond) bond = model.bond(outbond) ; line = line + 1 ; if bond.flow if strcmp(interface_class,'De') ese(line) = specify_ese(next_branch,[2*outmap],branch,{1},[]) ; else ese(line) = specify_ese(next_branch,[2*outmap],branch,[2*outbond],[]) ; end else ese(line) = specify_ese(branch,[2*outbond],next_branch,[2*outmap],[]) ; end line = line + 1 ; if bond.effort ese(line) = specify_ese(branch,[2*outbond-1],next_branch,[2*outmap-1],[]) ; else if strcmp(interface_class,'Df') ese(line) = specify_ese(next_branch,[2*outmap-1],branch,{1},[]) ; else ese(line) = specify_ese(next_branch,[2*outmap-1],branch,[2*outbond-1],[]) ; end end end end [object,object_ese,object_namelist] = specify_equations(object,next_branch,namelist) ; model = setfield(model,'obj',object_name,object) ; ese = [ese, object_ese] ; line = length(ese) ; namelist = object_namelist ; end object.cr = mttDeleteField(object.cr,'used_operator') ; model = setfield(model,'obj',object_name,object) ; end function equation = specify_ese(LHS_branch,LHS_var,RHS_branch,RHS_var,operator) equation.branch.LHS = LHS_branch ; equation.branch.RHS = RHS_branch ; equation.var.LHS = LHS_var ; equation.var.RHS = RHS_var ; equation.operator = operator ; function [branchlist,branchbond] = identify_branches(model,branch) is_root_model = (nargin==1) ; if is_root_model branch = mttDetachText(model.source,'/') ; branchlist{1} = branch ; branchbond = length(model.bond) ; counter = 1 ; else branchlist = [] ; branchbond = 0 ; counter = 0 ; end objects = mttGetFieldNames(model,'obj') ; for n = 1:length(objects) object_name = objects{n} ; object = getfield(model,'obj',object_name) ; next_branch = [branch,'__',object_name] ; [next_branchlist,next_branchbond] = identify_branches(object,next_branch) ; counter = counter + 1 ; branchlist{counter} = next_branch ; if isfield(object,'bond') branchbond(counter) = length(object.bond) ; else branchbond(counter) = 0 ; end for i = 1:length(next_branchlist) counter = counter + 1 ; branchlist{counter} = next_branchlist{i} ; branchbond(counter) = next_branchbond(i) ; end end function [sse,sorted_equations] = sort_equations(ese,model,namelist) mttWriteNewLine ; mttNotify('...sorting equations') ; mttWriteNewLine ; [branchlist,branchbond] = identify_branches(model) ; lastvar = cumsum(2*branchbond) ; offsetvar = lastvar - 2*branchbond ; number_of_equations = length(ese) ; % number_of_covariables = length(namelist) - 1 ; % number_of_interface_variables = max(lastvar) ; number_of_covariables = max(lastvar) ; number_of_interface_variables = length(namelist) - 1 ; mttNotifyEquationSummary(number_of_equations,number_of_covariables,number_of_interface_variables) ; for i = 1:length(ese) if isempty(ese(i).operator) var = ese(i).var.LHS ; switch class(var) case 'double', branch_index = strmatch(ese(i).branch.LHS,branchlist,'exact') ; info(i).LHS = abs(var) + offsetvar(branch_index) ; case 'cell', info(i).LHS = ese(i).var.LHS ; end var = ese(i).var.RHS ; switch class(var) case 'double', branch_index = strmatch(ese(i).branch.RHS,branchlist,'exact') ; for j = 1:length(var) info(i).RHS(j) = abs(var(j)) + offsetvar(branch_index) ; end case 'cell', info(i).RHS = ese(i).var.RHS ; end else info(i).LHS = ese(i).var.LHS ; info(i).RHS = ese(i).var.RHS ; end end var_known = zeros(max(lastvar),1) ; name_known = zeros(length(namelist),1) ; name_known(1) = 1 ; log = ones(length(ese),1) ; map = zeros(length(ese),1) ; counter = 0 ; for i = 1:length(ese) if log(i) & isempty(ese(i).operator) left = info(i).LHS ; right = info(i).RHS ; if isnumeric(left) & iscell(right) name = namelist(right{1}).var ; is_object_interface = ~isempty(findstr(name,'___')) ; ok = 1 ; if is_object_interface is_effort_state = ~isempty(findstr(name,'.effort_state')) ; is_flow_state = ~isempty(findstr(name,'.flow_state')) ; ok = is_effort_state | is_flow_state ; end if ok log(i) = 0 ; counter = counter + 1 ; map(counter) = i ; var_known(left) = 1 ; name_index = strmatch(name,{namelist.var},'exact') ; name_known(name_index) = 1 ; end end if iscell(left) & iscell(right) if right{1}==1 log(i) = 0 ; counter = counter + 1 ; map(counter) = i ; name = namelist(left{1}).var ; name_index = strmatch(name,{namelist.var},'exact') ; name_known(name_index) = 1 ; end end end end previous_var_known = var_known ; previous_name_known = name_known ; sort_iteration = 0 ; sorting = 1 ; while sorting sort_iteration = sort_iteration + 1 ; for i = 1:length(ese) if log(i) & isempty(ese(i).operator) left = info(i).LHS ; right = info(i).RHS ; if isnumeric(right) if all(var_known(right)) log(i) = 0 ; counter = counter + 1 ; map(counter) = i ; if isnumeric(left) var_known(left) = 1 ; else name = namelist(left{1}).var ; name_index = strmatch(name,{namelist.var},'exact') ; name_known(name_index) = 1 ; end end else name = namelist(right{1}).var ; name_index = strmatch(name,{namelist.var},'exact') ; if name_known(name_index) is_object_interface = ~isempty(findstr(name,'___')) ; if is_object_interface log(i) = 0 ; counter = counter + 1 ; map(counter) = i ; var_known(left) = 1 ; end end end end end for i = 1:length(ese) if log(i) & ~isempty(ese(i).operator) left = info(i).LHS ; right = info(i).RHS ; indices = [] ; for j = 1:length(right) name = namelist(right{j}).var ; indices(j) = strmatch(name,{namelist.var},'exact') ; end if all(name_known(indices)) log(i) = 0 ; counter = counter + 1 ; map(counter) = i ; for j = 1:length(left) name = namelist(left{j}).var ; name_index = strmatch(name,{namelist.var},'exact') ; name_known(name_index) = 1 ; end end end end same_vars_known = sum(var_known)==sum(previous_var_known) ; same_names_known = sum(name_known)==sum(previous_name_known) ; previous_var_known = var_known ; previous_name_known = name_known ; sorting = ~(same_vars_known & same_names_known) ; if sorting mttNotify(['...iteration ',num2str(sort_iteration)]) ; mttWriteNewLine ; % is_complete = ... % mttNotifyEquationSort(sort_iteration,... % sum(log),number_of_equations,... % sum(name_known),number_of_covariables,... % sum(var_known),number_of_interface_variables) ; is_complete = ... mttNotifyEquationSort(sort_iteration,... sum(log),number_of_equations,... sum(var_known),number_of_covariables,... sum(name_known),number_of_interface_variables) ; sorting = sorting & ~is_complete ; end end for i = 1:length(ese) if log(i) & isempty(ese(i).operator) left = info(i).LHS ; right = info(i).RHS ; if iscell(left) & isnumeric(right) name = namelist(left{1}).var ; is_object_interface = ~isempty(findstr(name,'___')) ; if ~is_object_interface if var_known(right) log(i) = 0 ; counter = counter + 1 ; map(counter) = i ; name_index = strmatch(name,{namelist.var},'exact') ; name_known(name_index) = 1 ; end end end end end sorted_equations = counter ; if sorted_equations<number_of_equations mttWriteNewLine ; mttNotify(['...unable to sort equations completely']) ; mttWriteNewLine ; mttNotifyEquationSortProblems(name_known,namelist) ; end for i = 1:length(ese) if log(i) counter = counter + 1 ; map(counter) = i ; end end mttAssert(counter==length(ese),'Sort algorithm has failed! Seek expert assistance!') ; for i = 1:length(ese) sse(i) = ese(map(i)) ; end function link = create_link(is_input,is_effort,is_flow,name,is_state) link.is_input = is_input ; link.is_effort = is_effort ; link.is_flow = is_flow ; link.name = name ; link.is_state = is_state ; link.is_unconstrained = [] ; function boolean = compare_links(actual_link,op_link) input_is_same = actual_link.is_input==op_link.is_input ; effort_is_same = actual_link.is_effort==op_link.is_effort ; flow_is_same = actual_link.is_flow==op_link.is_flow ; name_is_same = strcmp(actual_link.name,op_link.name) ; boolean = input_is_same & effort_is_same & flow_is_same & name_is_same ; |
Added mttroot/ntt/bin/trans/m/mttCreateEnvironment.m version [9307cb976f].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 | function model = mttCreateEnvironment(context) global mtt_env mttNotify('...setting "env" definition') ; mttWriteNewLine ; directory_name = identify_directory_name(context) ; source_name = identify_source_name(context,directory_name) ; environment_filename = [source_name,'_env.txt'] ; model = mttFetchEnvironment(environment_filename) ; model = establish_path_names(model) ; mttWriteNewLine ; mttNotify('...acquiring "domain" source definitions') ; mttWriteNewLine ; model = establish_user_domains(model) ; number_of_domains = mttGetFieldLength(model,'dom') ; if number_of_domains>0 for i = 1:number_of_domains model.public_domain(i).representation = model.dom(i).representation ; model.public_domain(i).source = model.dom(i).source ; domain = model.dom(i) ; item_names = mttGetFieldNames(domain,'item') ; for j = 1:length(item_names) item_name = item_names{j} ; item = getfield(domain,'item',item_name) ; compound_item = mttIdentifyDomainCovariables(item,domain,model) ; model = setfield(model,'public_domain',{i},'item',item_name,compound_item) ; end end model = hide_private_domains(model) ; end model = mttDeleteField(model,'dom') ; mttWriteNewLine ; mttNotify('...acquiring "struct" source definitions') ; mttWriteNewLine ; model = establish_user_structs(model) ; number_of_structs = mttGetFieldLength(model,'str') ; if number_of_structs>0 for i = 1:number_of_structs model.public_struct(i).representation = model.str(i).representation ; model.public_struct(i).source = model.str(i).source ; struct = model.str(i) ; item_names = mttGetFieldNames(struct,'item') ; for j = 1:length(item_names) item_name = item_names{j} ; item = getfield(struct,'item',item_name) ; compound_item = mttIdentifyStructVariables(item,struct,model) ; model = setfield(model,'public_struct',{i},'item',item_name,compound_item) ; end end model = hide_private_structs(model) ; end model = mttDeleteField(model,'str') ; function directory = identify_directory_name(context) mttAssert(ischar(context),'Context must be specified by name') ; working_directory = pwd ; working_directory = strrep(working_directory,'\','/') ; [system_name,local_directory] = mttDetachText(context,'/') ; if isempty(system_name) local_directory = [] ; end if isempty(local_directory) directory = working_directory ; else directory = mttLocateDirectory(working_directory,local_directory) ; end function source = identify_source_name(context,directory) [context_name,local_directory] = mttDetachText(context,'/') ; if isempty(context_name) context_name = context ; local_directory = [] ; end source = [directory,'/',context_name] ; function model = establish_path_names(model) path_names = mttGetFieldNames(model,'path') ; for n = 1:length(path_names) path_name = path_names{n} ; path_spec = getfield(model,'path',path_name) ; [rubbish,working_directory] = mttDetachText(model.source,'/') ; directory = identify_directory(working_directory,path_spec,model) ; mttAssert(~isempty(directory),... ['Undefined path "',path_name,'"']) ; model = setfield(model,'path',path_name,directory) ; end function directory = identify_directory(working_directory,path_spec,model) path_names = mttGetFieldNames(model,'path') ; if isempty(path_spec) directory = [] ; else if path_spec(1)=='$' [path_alias,path_branch] = mttCutText(path_spec,'/') ; path_alias(1) = [] ; mttAssert(ismember(path_alias,path_names),... ['Path "',path_alias,'" not recognised']) ; path_root = getfield(model,'path',path_alias) ; if isempty(path_branch) directory = path_root ; else directory = [path_root,'/',path_branch] ; end else [local_directory,name] = mttCutText(path_spec,'/') ; directory_located = 0 ; if strcmp(local_directory,'.') if isempty(name) directory = working_directory ; directory_located = 1 ; else local_directory = name ; end else local_directory = path_spec ; end if ~directory_located directory = mttLocateDirectory(working_directory,local_directory) ; end end end function model = establish_user_domains(model) path_names = mttGetFieldNames(model,'path') ; domain_names = mttGetFieldNames(model,'domain') ; counter = 0 ; for n = 1:length(domain_names) domain_name = domain_names{n} ; domain_spec = getfield(model,'domain',domain_name) ; [rubbish,working_directory] = mttDetachText(model.source,'/') ; [domain_source,domain_item] = mttCutText(domain_spec,'::') ; [name,path_spec] = mttDetachText(domain_source,'/') ; if isempty(name) source_name = [working_directory,'/',domain_source] ; else directory = identify_directory(working_directory,path_spec,model) ; source_name = [directory,'/',name] ; end domain_filename = [source_name,'_domain.txt'] ; domain_index = [] ; if isfield(model,'dom') existing_doms = {model.dom.source} ; domain_index = strmatch(source_name,existing_doms,'exact') ; end if isempty(domain_index) counter = counter + 1 ; model.dom(counter) = mttFetchDomain(domain_filename) ; domain_index = counter ; end domain_spec.dom = domain_index ; domain_spec.item = domain_item ; model = setfield(model,'domain',domain_name,domain_spec) ; end function model = hide_private_domains(model) for n = 1:mttGetFieldLength(model,'public_domain') dom = model.dom(n) ; dom_items = dom.item ; domain = model.public_domain(n) ; domain_items = domain.item ; item_names = mttGetFieldNames(domain,'item') ; for j = 1:length(item_names) item_name = item_names{j} ; is_private(j) = getfield(dom_items,item_name,'is_private') ; if is_private(j) domain_items = mttDeleteField(domain_items,item_name) ; mttAssert(~isempty(domain_items),... ['No public domains in ',dom.source]) ; end end model = setfield(model,'public_domain',{n},'item',domain_items) ; end user_domain_names = mttGetFieldNames(model,'domain') ; for i = 1:length(user_domain_names) user_domain_name = user_domain_names{i} ; user_domain = getfield(model,'domain',user_domain_name) ; dom = model.dom(user_domain.dom) ; if ~isempty(user_domain.item) is_private = getfield(dom,'item',user_domain.item,'is_private') ; mttAssert(~is_private,... ['User-defined domain "',user_domain_name,'" is declared as private']) ; end end function model = establish_user_structs(model) path_names = mttGetFieldNames(model,'path') ; struct_names = mttGetFieldNames(model,'struct') ; counter = 0 ; for n = 1:length(struct_names) struct_name = struct_names{n} ; struct_spec = getfield(model,'struct',struct_name) ; [rubbish,working_directory] = mttDetachText(model.source,'/') ; [struct_source,struct_item] = mttCutText(struct_spec,'::') ; [name,path_spec] = mttDetachText(struct_source,'/') ; if isempty(name) source_name = [working_directory,'/',struct_source] ; else directory = identify_directory(working_directory,path_spec,model) ; source_name = [directory,'/',name] ; end struct_filename = [source_name,'_struct.txt'] ; struct_index = [] ; if isfield(model,'str') existing_strs = {model.str.source} ; struct_index = strmatch(source_name,existing_strs,'exact') ; end if isempty(struct_index) counter = counter + 1 ; model.str(counter) = mttFetchStruct(struct_filename) ; struct_index = counter ; end struct_spec.str = struct_index ; struct_spec.item = struct_item ; model = setfield(model,'struct',struct_name,struct_spec) ; end function model = hide_private_structs(model) for n = 1:mttGetFieldLength(model,'public_struct') str = model.str(n) ; str_items = str.item ; struct = model.public_struct(n) ; struct_items = struct.item ; item_names = mttGetFieldNames(struct,'item') ; for j = 1:length(item_names) item_name = item_names{j} ; is_private(j) = getfield(str_items,item_name,'is_private') ; if is_private(j) struct_items = mttDeleteField(struct_items,item_name) ; mttAssert(~isempty(struct_items),... ['No public structs in ',str.source]) ; end end model = setfield(model,'public_struct',{n},'item',struct_items) ; end user_struct_names = mttGetFieldNames(model,'struct') ; for i = 1:length(user_struct_names) user_struct_name = user_struct_names{i} ; user_struct = getfield(model,'struct',user_struct_name) ; str = model.str(user_struct.str) ; if ~isempty(user_struct.item) is_private = getfield(str,'item',user_struct.item,'is_private') ; mttAssert(~is_private,... ['User-defined struct "',user_struct_name,'" is declared as private']) ; end end |
Added mttroot/ntt/bin/trans/m/mttCreateSystemMdl.m version [1ef68305e6].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 | function mttCreateSystemMdl(model) model_name = mttDetachText(model.source,'/') ; icd = mttCreateSystemMdl_ICD(model) ; NumInputs = length(icd.input_namelist) ; NumOutputs = length(icd.output_namelist) ; MaxInterfaces = max(NumInputs,NumOutputs) ; new_system(model_name) ; open_system(model_name) ; set_param(model_name,'Location',[50 100 850 250+20*MaxInterfaces]) ; left = 100 ; top = 25 ; width = 600 ; height = 25*(5+MaxInterfaces) ; position_vector = [left,top,left+width,top+height] ; ModelHndl = add_block(... 'simulink3/Subsystems/Subsystem',... [model_name,'/Model'],... 'Position',position_vector,... 'BackgroundColor','yellow',... 'FontName','Helvetica',... 'FontSize',num2str(16)) ; system = [model_name,'/Model'] ; set_param(system,'Location',[200 250 1050 285+30*MaxInterfaces]) ; Line = get_param(system,'Lines') ; for i = 1:length(Line) SrcBlock = get_param(Line(i).SrcBlock,'Name') ; DstBlock = get_param(Line(i).DstBlock,'Name') ; SrcPort = num2str(Line(i).SrcPort) ; DstPort = num2str(Line(i).DstPort) ; delete_line(system,[SrcBlock,'/',SrcPort],[DstBlock,'/',DstPort]) ; end Block = get_param(system,'Blocks') ; for i = 1:length(Block) delete_block([system,'/',Block{i}]) ; end left = 125 ; centre_left = 250 ; centre = 350 ; centre_right = 580 ; right = 670 ; top = 20 ; down = 30 ; port_width = 40 ; port_height = 15 ; port_spacing = down ; mux_width = 5 ; mux_height = NumInputs*port_spacing ; demux_width = 5 ; demux_height = NumOutputs*port_spacing ; sfun_width = 150 ; sfun_height = 30 ; left_vertical_offset = (NumInputs*port_spacing - sfun_height)/2 ; right_vertical_offset = (NumOutputs*port_spacing - sfun_height)/2 ; vertical_offset = max(left_vertical_offset,right_vertical_offset) ; datum = top + vertical_offset ; top = datum - left_vertical_offset ; for i = 1:NumInputs position_vector = [... left,... top + (i-1)*port_spacing,... left + port_width,... top + (i-1)*port_spacing + port_height] ; InHndl(i) = add_block(... 'simulink3/Sources/In1',... [system,'/',icd.input_namelist{i}],... 'Position',position_vector) ; end position_vector = [... centre_left,... top-port_height/3,... centre_left+mux_width,... top+mux_height-port_height/3] ; MuxHndl = add_block(... 'simulink3/Signals & Systems/Mux',... [system,'/InputMapping'],... 'Position',position_vector,... 'Inputs',num2str(NumInputs)) ; position_vector = [... centre,... top+left_vertical_offset-sfun_height/2,... centre+sfun_width,... top+left_vertical_offset+sfun_height] ; SfunHndl = add_block(... 'simulink3/Functions & Tables/S-Function',... [system,'/sfun'],... 'Position',position_vector,... 'FunctionName',[model_name,'_sfun'],... 'BackgroundColor','yellow',... 'FontName','Helvetica',... 'FontSize',num2str(16)) ; top = datum - right_vertical_offset ; position_vector = [... centre_right,... top-port_height/3,... centre_right+demux_width,... top+demux_height-port_height/3] ; DemuxHndl = add_block(... 'simulink3/Signals & Systems/Demux',... [system,'/OutputMapping'],... 'Position',position_vector,... 'Outputs',num2str(NumOutputs)) ; for i = 1:NumOutputs position_vector = [... right,... top + (i-1)*port_spacing,... right + port_width,... top + (i-1)*port_spacing + port_height] ; OutHndl(i) = add_block(... 'simulink3/Sinks/Out1',... [system,'/',icd.output_namelist{i}],... 'Position',position_vector) ; end for i = 1:NumInputs port = num2str(i) ; InLineHndl(i) = add_line(system,... [icd.input_namelist{i},'/1'],['InputMapping/',port]) ; end SfunInLineHndl = add_line(system,'InputMapping/1','sfun/1') ; set_param(SfunInLineHndl,'Name','_Input') ; SfunOutLineHndl = add_line(system,'sfun/1','OutputMapping/1') ; set_param(SfunOutLineHndl,'Name','_Output') ; for i = 1:NumOutputs port = num2str(i) ; OutLineHndl(i) = add_line(system,... ['OutputMapping/',port],[icd.output_namelist{i},'/1']) ; end |
Added mttroot/ntt/bin/trans/m/mttCreateSystemMdl_ICD.m version [ca430de00e].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 | function icd = mttCreateSystemMdl_ICD(model) sympar = map_system_sympars(model) ; input = map_system_inputs(model) ; invar = map_system_invars(model) ; outvar = map_system_outvars(model) ; icd.output_namelist = outvar ; icd.input_namelist = invar ; if ~isempty(input) icd.input_namelist = [icd.input_namelist,input] ; end if ~isempty(sympar) icd.input_namelist = [icd.input_namelist,sympar] ; end icd.output_namelist = sort(icd.output_namelist) ; icd.input_namelist = sort(icd.input_namelist) ; function map = map_system_sympars(model) mttNotify('...mapping system inputs (symbolic parameters)') ; mttWriteNewLine ; map = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'sympar') ; model_name = mttDetachText(model.source,'/') ; for i = 1:number_of_variables variable_name = model.sympar{i} ; default_value = model.sympar_default{i} ; if isempty(default_value) line = line + 1 ; map{line} = [model_name,'___',variable_name] ; end end function map = map_system_inputs(model,root,branch) is_root_model = nargin==1 ; if is_root_model mttNotify('...mapping system inputs (input variables)') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; else current_branch = branch ; end map = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'input') ; for i = 1:number_of_variables variable_name = model.input{i} ; line = line + 1 ; map{line} = [current_branch,'___',variable_name] ; end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; additional_map = [] ; if ~isempty(object.abg) additional_map = map_system_inputs(object,root,next_branch) ; elseif ~isempty(object.cr) additional_map = map_system_inputs(object.cr,root,next_branch) ; end if isempty(map) map = additional_map ; else line = length(map) ; for j = 1:length(additional_map) if ~ismember(additional_map{j},map) line = line + 1 ; map{line} = additional_map{j} ; end end end end function map = map_system_invars(model,root,branch,env) is_root_model = nargin==1 ; if is_root_model mttNotify('...mapping system inputs (input covariables)') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; env = model.env ; else current_branch = branch ; end map = [] ; line = 0 ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; switch object.class case {'SS','Se','Sf','De','Df'} inbond_number = object.interface.in ; outbond_number = object.interface.out ; inbond = model.bond(inbond_number) ; outbond = model.bond(outbond_number) ; if ~isempty(inbond) covariables = mttGetCovariables(env,inbond.domain,inbond.domain_item) ; covar = [] ; if ~inbond.effort if ~strcmp(object.class,'Df') covar = covariables.effort ; end elseif inbond.flow if ~strcmp(object.class,'De') covar = covariables.flow ; end end for j = 1:length(covar) line = line + 1 ; covariable = strrep(covar{j},'.','__') ; map{line} = [current_branch,'__',object_name,'(',covariable,')'] ; end end if ~isempty(outbond) covariables = mttGetCovariables(env,outbond.domain,outbond.domain_item) ; if outbond.effort covar = covariables.effort ; elseif ~outbond.flow covar = covariables.flow ; end for j = 1:length(covar) line = line + 1 ; covariable = strrep(covar{j},'.','__') ; map{line} = [current_branch,'__',object_name,'(',covariable,')'] ; end end end additional_map = [] ; if ~isempty(object.abg) additional_map = map_system_invars(object,root,next_branch,env) ; end if isempty(map) map = additional_map ; else line = length(map) ; for j = 1:length(additional_map) if ~ismember(additional_map{j},map) line = line + 1 ; map{line} = additional_map{j} ; end end end end function map = map_system_outvars(model,root,branch,env) is_root_model = nargin==1 ; if is_root_model mttNotify('...mapping system outputs (output covariables)') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; env = model.env ; else current_branch = branch ; end map = [] ; line = 0 ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; switch object.class case {'SS','Se','Sf','De','Df'} inbond_number = object.interface.in ; outbond_number = object.interface.out ; inbond = model.bond(inbond_number) ; outbond = model.bond(outbond_number) ; if ~isempty(inbond) covariables = mttGetCovariables(env,inbond.domain,inbond.domain_item) ; covar = [] ; if inbond.effort covar = covariables.effort ; elseif ~inbond.flow covar = covariables.flow ; end for j = 1:length(covar) line = line + 1 ; covariable = strrep(covar{j},'.','__') ; map{line} = [current_branch,'__',object_name,'(',covariable,')'] ; end end if ~isempty(outbond) covariables = mttGetCovariables(env,outbond.domain,outbond.domain_item) ; covar = [] ; if ~outbond.effort if ~strcmp(object.class,'Sf') covar = covariables.effort ; end elseif outbond.flow if ~strcmp(object.class,'Se') covar = covariables.flow ; end end for j = 1:length(covar) line = line + 1 ; covariable = strrep(covar{j},'.','__') ; map{line} = [current_branch,'__',object_name,'(',covariable,')'] ; end end end additional_map = [] ; if ~isempty(object.abg) additional_map = map_system_outvars(object,root,next_branch,env) ; end if isempty(map) map = additional_map ; else line = length(map) ; for j = 1:length(additional_map) if ~ismember(additional_map{j},map) line = line + 1 ; map{line} = additional_map{j} ; end end end end |
Added mttroot/ntt/bin/trans/m/mttCreateUnifiedModel.m version [27142f9b00].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 | function model = mttCreateUnifiedModel(model,bondgraph,specification) model.source = mttCutText(specification.specification,'_abg.txt') ; model.bondgraph = mttCutText(bondgraph.bondgraph,'_abg.fig') ; model.obj = bondgraph.obj ; model.bond = bondgraph.bond ; object_names = mttGetFieldNames(model,'obj') ; specified_object_names = mttGetFieldNames(specification,'obj') ; for n = 1:length(object_names) object_name = object_names{n} ; object = getfield(model,'obj',object_name) ; if ~mttIsPassiveClass(object.class) mttAssert(ismember(object_name,specified_object_names),... ['Object name "',object_name,'" does not appear in specification']) ; end end for n = 1:length(specified_object_names) specified_object_name = specified_object_names{n} ; mttAssert(ismember(specified_object_name,object_names),... ['Specified object name "',specified_object_name,... '" does not appear in bond graph']) ; specified_object = getfield(specification,'obj',specified_object_name) ; object = getfield(model,'obj',specified_object_name) ; if strcmp(specified_object.name.class,object.class) mttAssert(~mttIsFoundationClass(object.class),... 'Cannot redefine MTT foundation class') ; is_abg = 1 ; else mttAssert(~mttIsPassiveClass(object.class),... 'Cannot modify MTT junctions or ports') ; is_abg = 0 ; end object.is_abg = is_abg ; object.name = specified_object.name ; object.parameter = specified_object.parameter ; model = setfield(model,'obj',specified_object_name,object) ; end model.sympar = specification.sympar ; model.numpar = specification.numpar ; model.input = specification.input ; model.sympar_default = specification.sympar_default ; model.numpar_default = specification.numpar_default ; model.input_default = specification.input_default ; for n = 1:length(object_names) object_name = object_names{n} ; object = getfield(model,'obj',object_name) ; if mttIsPortClass(object.class) mttAssert(mttGetFieldLength(object,'interface')==1,... ['Port components must have one and only one interface']) ; switch object.class case {'Se','Sf'}, mttAssert(~isempty(object.interface.out),... 'Each source port must have an outward bond') ; case {'De','Df'}, mttAssert(~isempty(object.interface.in),... 'Each detector port must have an inward bond') ; end end if ~ismember(object_name,specified_object_names) object.name.item = [] ; object.name.class = object.class ; object.name.path = [] ; object.parameter = [] ; object.is_abg = 1 ; end [rubbish,working_directory] = mttDetachText(model.source,'/') ; local_directory = object.name.path ; directory = mttLocateDirectory(working_directory,local_directory) ; source = [directory,'/',object.name.class] ; current_leaf = model.leaf ; if object.is_abg if mttIsPassiveClass(object.name.class) object.abg = [] ; else current_branch = model.branch ; mttAssert(~ismember(source,current_branch),... ['Recursive definition of "',source,'"']) ; if isempty(model.abgs) existing_abg = [] ; else existing_abg = strmatch(source,model.abgs,'exact') ; end if isempty(existing_abg) if isempty(current_branch) next_branch = {source} ; next_leaf = object_name ; else next_branch = [current_branch,{source}] ; next_leaf = [current_leaf,'/',object_name] ; end model.branch = next_branch ; model.leaf = next_leaf ; class_model = mttCreateAcausalBondgraph(source,model) ; model.leaf = current_leaf ; model.branch = current_branch ; next_abg = 1 + mttGetFieldLength(model,'abg') ; for i = 1:mttGetFieldLength(class_model,'abg') model.abg(next_abg) = class_model.abg(i) ; model.abgs = class_model.abgs ; next_abg = next_abg + 1 ; end class_model = mttDeleteField(class_model,'abg') ; model.crs = class_model.crs ; class_model = mttDeleteField(class_model,'crs') ; model.cr_usage = class_model.cr_usage ; class_model = mttDeleteField(class_model,'cr_usage') ; model.abg(next_abg) = class_model ; model = mttAppend(model,'abgs',{source}) ; index = length(model.abgs) ; mttNotify([' ...made "#',num2str(index),':',object.name.class,'" definition']) ; mttWriteNewLine ; end object.abg = strmatch(source,model.abgs,'exact') ; end object.cr = [] ; object.cr_item = [] ; else if isempty(model.crs) existing_cr = [] ; else existing_cr = strmatch(source,model.crs,'exact') ; end if isempty(current_leaf) cr_user = object_name ; else cr_user = [current_leaf,'/',object_name] ; end if isempty(existing_cr) model = mttAppend(model,'crs',{source}) ; N = length(model.crs) ; model.cr_usage(N).obj{1} = cr_user ; else N = 1+length(model.cr_usage(existing_cr).obj) ; model.cr_usage(existing_cr).obj{N} = cr_user ; end object.abg = [] ; object.cr = strmatch(source,model.crs,'exact') ; if isempty(object.name.item) object.cr_item = mttDetachText(model.crs{object.cr},'/') ; else object.cr_item = object.name.item ; end end object = mttDeleteField(object,'name') ; object = mttDeleteField(object,'is_abg') ; model = setfield(model,'obj',object_name,object) ; end |
Added mttroot/ntt/bin/trans/m/mttEmbedAcausalBondgraph.m version [a4a8eda9a1].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 | function model = mttEmbedAcausalBondgraph(model,component,system) source = model.abg(component) ; if nargin==2 is_root_model = 1 ; target = model ; else is_root_model = 0 ; target = model.abg(system) ; end source_objects = mttGetFieldNames(source,'obj') ; target_objects = mttGetFieldNames(target,'obj') ; for n = 1:length(target_objects) target_object_name = target_objects{n} ; target_object = getfield(target,'obj',target_object_name) ; here = [mttDetachText(target.source,'/'),'/',target_object_name] ; is_abg_instance = 0 ; if ~isempty(target_object.abg) is_abg_instance = target_object.abg==component ; end if is_abg_instance target_object.sympar = source.sympar ; target_object.numpar = source.numpar ; target_object.input = source.input ; target_object.sympar_default = source.sympar_default ; target_object.numpar_default = source.numpar_default ; target_object.input_default = source.input_default ; declarations = length(target_object.sympar) ; values = length(target_object.parameter) ; mttAssert(declarations==values,['Mismatched parameters in object ',here]) ; number_of_target_ports = mttGetFieldLength(target_object,'interface') ; found_target_port = [] ; target_ports_found = [] ; for i = 1:number_of_target_ports target_port_name = target_object.interface(i).name ; target_inbond = target_object.interface(i).in ; target_outbond = target_object.interface(i).out ; is_inline = (~isempty(target_inbond) & ~isempty(target_outbond)) ; next = 0 ; found_target_port(i) = 0 ; matching = 1 ; while matching next = next + 1 ; source_object_name = source_objects{next} ; source_object = getfield(source,'obj',source_object_name) ; if ismember(source_object.class,{'SS','Se','Sf','De','Df'}) source_port_name = source_object_name ; if is_inline source_interface = getfield(source,'obj',source_port_name,'interface') ; inport_found = 0 ; if ~isempty(source_interface.in) inport_found = strcmp(source_port_name,[target_port_name,'_in']) ; end outport_found = 0 ; if ~isempty(source_interface.out) outport_found = strcmp(source_port_name,[target_port_name,'_out']) ; end found_target_port(i) = inport_found | outport_found ; else found_target_port(i) = strcmp(source_port_name,target_port_name) ; end end if found_target_port(i) if isempty(target_ports_found) target_ports_found = {target_port_name} ; else target_ports_found = [target_ports_found, {target_port_name}] ; end matching = 0 ; else matching = (next<length(source_objects)) ; end end mttAssert(found_target_port(i),... ['Unmatched port "',target_object_name,'[',target_port_name,']"']) ; source_object = getfield(source,'obj',source_port_name) ; source_inbond = source_object.interface.in ; source_outbond = source_object.interface.out ; source_class = source_object.class ; source_domain = source_object.domain ; source_domain_item = source_object.domain_item ; is_inward_compatible = ~xor(isempty(target_inbond),isempty(source_outbond)) ; is_outward_compatible = ~xor(isempty(target_outbond),isempty(source_inbond)) ; is_compatible = is_inward_compatible & is_outward_compatible ; mttAssert(is_compatible,... ['Incompatible bond connections at port "',... target_object_name,'[',target_port_name,']"']) ; target_object = setfield(target_object,'interface',{i},'map','in',source_outbond) ; target_object = setfield(target_object,'interface',{i},'map','out',source_inbond) ; target_object = setfield(target_object,'interface',{i},'class',source_class) ; target_object = setfield(target_object,'interface',{i},'domain',source_domain) ; target_object = setfield(target_object,'interface',{i},'domain_item',source_domain_item) ; end number_of_target_ports_found = sum(found_target_port) ; mttAssert(number_of_target_ports_found==number_of_target_ports,... ['Mismatched ports in "',target_object_name,'"']) ; for i = 1:length(source_objects) source_object_name = source_objects{i} ; if ~ismember(source_object_name,target_ports_found) source_object = getfield(source,'obj',source_object_name) ; source_object = mttDeleteField(source_object,'cr_item') ; target_object = setfield(target_object,'obj',source_object_name,source_object) ; end end source_bond_list = getfield(source,'bond') ; target_object = setfield(target_object,'bond',source_bond_list) ; target = setfield(target,'obj',target_object_name,target_object) ; end end if is_root_model model = target ; else if ~isempty(target.invokes) invoked_abgs = target.invokes ; other_abgs = target.invokes(invoked_abgs~=component) ; if isempty(other_abgs) target.invokes = [] ; else target.invokes = other_abgs ; end end model.abg(system) = target ; end |
Added mttroot/ntt/bin/trans/m/mttEmbedInterfaceDefinition.m version [b375cb1133].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | function model = mttEmbedInterfaceDefinition(model,object_name,root) if nargin==2 root = model ; end here = [mttDetachText(model.source,'/'),'/',object_name] ; object = getfield(model,'obj',object_name) ; cr = root.cr(object.cr) ; cr_item_name = object.cr_item ; cr_item_names = mttGetFieldNames(cr,'item') ; mttAssert(ismember(cr_item_name,cr_item_names),... ['CR "',cr_item_name,'" not found']) ; cr_item = getfield(cr,'item',cr_item_name) ; cr_portnames = mttGetFieldNames(cr_item.interface,'port') ; for i = 1:mttGetFieldLength(object,'interface') interface_name = object.interface(i).name ; mttAssert(ismember(interface_name,cr_portnames),... ['Unrecognised interface "',interface_name,'" in object ',here]) ; interface = getfield(cr_item,'interface','port',interface_name) ; interface.in = object.interface(i).in ; interface.out = object.interface(i).out ; has_inbond = ~isempty(object.interface(i).in) ; has_outbond = ~isempty(object.interface(i).out) ; mttAssert(xor(has_inbond,has_outbond),... ['Mismatched interface "',interface_name,'" in object ',here]) ; cr_item = setfield(cr_item,'interface','port',interface_name,interface) ; end for i = 1:length(cr_portnames) port_name = cr_portnames{i} ; cr_item_port = getfield(cr_item,'interface','port',port_name) ; mttAssert(isfield(cr_item_port,'in')|isfield(cr_item_port,'out'),... ['Unmatched port ',here,':',port_name]) ; end object.sympar = cr_item.sympar ; object.sympar_default = cr_item.sympar_default ; cr_item = mttDeleteField(cr_item,'parameter') ; object.cr = cr_item ; declarations = length(object.sympar) ; values = length(object.parameter) ; mttAssert(declarations==values,... ['Mismatched parameters in object ',here]) ; object = mttDeleteField(object,'cr_item') ; model = setfield(model,'obj',object_name,object) ; |
Added mttroot/ntt/bin/trans/m/mttFetchApps.m version [637cce0534].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 | function model = mttFetchApps(filename) if ~mttFileExists(filename) model = [] ; return ; end model.representation = 'apps' ; mttNotify(['...processing ',filename]) ; mttWriteNewLine ; model.source = mttCutText(filename,'_apps.txt') ; model_name = mttDetachText(model.source,'/') ; content = mttReadFile(filename) ; statements = mttExtractStatements(content) ; number_of_statements = length(statements) ; apps_declared = 0 ; next = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'apps', mttAssert(~apps_declared,... '"apps" declaration must be unique') ; apps_declared = 1 ; apps_name = line ; mttAssert(strcmp(apps_name,model_name),... ['Wrong name:[',apps_name,'] Expecting:[',model_name,']']) ; [apps,next] = fetch_apps(statements,next) ; model = mttAppendFields(model,apps) ; case '{', error('Unexpected "{" found') ; case '}', error('Unexpected "}" found') ; otherwise, error(['Unrecognised top-level keyword "',keyword,'"']) ; end if next==number_of_statements parsing = 0 ; end end function [apps,next] = fetch_apps(statements,next) apps = [] ; unit_name = 'apps' ; number_of_statements = length(statements) ; open = 0 ; counter = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'app', mttAssert(open,... ['"app" declarations must be contained inside {...} in "',unit_name,'"']) ; app_name = line ; counter = counter + 1 ; apps.app{counter} = app_name ; case '{', mttAssert(~open,['Unmatched "{" in "',unit_name,'"']) ; open = 1 ; case '}', mttAssert(open,['Unmatched "}" in "',unit_name,'"']) ; open = 0 ; otherwise, error(['Unrecognised_keyword "',keyword,'" in "',unit_name,'"']) ; end mttAssert(~(open & (next==number_of_statements)),... ['Missing "}" in "',unit_name,'"']) ; if (~open) | (next==number_of_statements) parsing = 0 ; end end apps = mttSetFieldDefault(apps,'app',[]) ; |
Added mttroot/ntt/bin/trans/m/mttFetchBondgraph.m version [521f373616].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 | function model = mttFetchBondgraph(filename) mttAssert(mttFileExists(filename),... ['File "',filename,'" not found']) ; mttNotify([' ...processing ',filename]) ; mttWriteNewLine ; model.bondgraph = filename ; content = mttReadFile(filename) ; L = length(content) ; N = 1 ; processing = (N<=L) ; while processing jump = 1 ; line = mttClipText(content{N}) ; if ~isempty(line) no_string_terminator = isempty(findstr('\001',line)) ; if no_string_terminator if mttIsNumericText(line) numbers = round(str2num(line)) ; % only interested in integer values if numbers(1)==2 % ... line definition forward_arrow = numbers(14)~=0 ; reverse_arrow = numbers(15)~=0 ; arrow = (forward_arrow | reverse_arrow) ; depth = numbers(7) ; is_visible = rem(depth,10)==0 ; if is_visible mttAssert(~arrow,... ['Line ',num2str(N),': Arrows are not recognised in bond graphs']) ; number_of_points = numbers(16) ; coordinate_string = [] ; M = 0 ; matching = 1 ; while matching M = M + 1 ; if isempty(coordinate_string) coordinate_string = content{N+M} ; else coordinate_string = [coordinate_string,' ',content{N+M}] ; end mttAssert(mttIsNumericText(coordinate_string),... ['Line ',num2str(N+M),': Coordinates not recognised']) ; coordinates = str2num(coordinate_string) ; matching = length(coordinates)<2*number_of_points ; end mttAssert(length(coordinates)==2*number_of_points,... ['Line ',num2str(N+1),': Wrong number of coordinates']) ; jump = jump + M ; if number_of_points==2 model = create_line(model,coordinates) ; elseif number_of_points>2 model = create_bond(model,coordinates) ; end else jump = jump + forward_arrow + reverse_arrow ; end end end else [last_word,first_part] = mttDetachText(line,' ') ; if mttIsNumericText(first_part) numbers = round(str2num(first_part)) ; % only interested in integer values if numbers(1)==4 % ... text definition depth = numbers(4) ; is_visible = rem(depth,10)==0 ; if is_visible coordinates = numbers(12:13) ; text = mttCompressText(mttCutText(last_word,'\001')) ; identifier = mttCutText(text,'[') ; qualifier = mttExtractText(text,'[',']') ; name.label = [] ; name.domain = [] ; name.domain_item = [] ; name.class = [] ; name.object = [] ; if isempty(identifier) name.label = qualifier ; model = create_label(model,name,coordinates) ; else [name.domain,name.domain_item] = mttCutText(qualifier,'::') ; [name.class,name.object] = mttCutText(identifier,':') ; model = create_object(model,name,coordinates) ; end end end end end end N = N + jump ; processing = (N<=L) ; end model = incorporate_anonymous_objects(model) ; model = identify_causal_assignments(model) ; model = identify_object_binding(model) ; model = identify_object_interfaces(model) ; model = associate_external_domains(model) ; model = tidy_up(model) ; function model = create_line(model,coordinates) next = 1 + mttGetFieldLength(model,'line') ; model.line(next).xy1 = coordinates(1:2) ; model.line(next).xy2 = coordinates(3:4) ; model.line(next).mid = (coordinates(1:2)+coordinates(3:4))/2 ; function model = create_bond(model,coordinates) next = 1 + mttGetFieldLength(model,'bond') ; N = length(coordinates) ; q1 = coordinates(N-1:N) ; p1 = coordinates(1:2) ; p2 = coordinates(3:4) ; q2 = coordinates(N-3:N-2) ; p3 = coordinates(5:6) ; q3 = coordinates(N-5:N-4) ; ps = norm(p2-p1) ; qs = norm(q2-q1) ; orientation = sign(ps-qs) ; switch orientation case 1, % harpoon points forward xy1 = p1 ; xy2 = q2 ; v1 = p2-p1 ; v2 = q2-q3 ; harpoon = q1-q2 ; case -1, % harpoon points backward xy1 = p2 ; xy2 = q1 ; v1 = q2-q1 ; v2 = p2-p3 ; harpoon = p1-p2 ; end harpoon_side = sign_cross_product(v2,harpoon) ; mttAssert(~(orientation==0 | harpoon_side==0),... ['Ambiguous bond orientation between[',num2str(xy1),'] and [',num2str(xy2),']']) ; model.bond(next).xy1 = xy1 ; model.bond(next).xy2 = xy2 ; model.bond(next).v1 = v1 ; model.bond(next).v2 = v2 ; model.bond(next).harpoon = harpoon ; model.bond(next).harpoon_side = harpoon_side ; model.bond(next).from.obj = [] ; model.bond(next).from.interface = [] ; model.bond(next).to.obj = [] ; model.bond(next).to.interface = [] ; model.bond(next).flow = [] ; model.bond(next).effort = [] ; model.bond(next).unicausal = [] ; model.bond(next).domain = [] ; model.bond(next).domain_item = [] ; function model = create_label(model,name,coordinates) inner_name = mttExtractText(name.label,'<','>') ; if isempty(inner_name) label_name = name.label ; is_inline = 0 ; else label_name = inner_name ; is_inline = 1 ; end mttValidateName(label_name) ; next = 1 + mttGetFieldLength(model,'label') ; model.label(next).name = label_name ; model.label(next).is_inline = is_inline ; model.label(next).xy = coordinates ; function model = create_object(model,name,coordinates) global mtt_environment domain_names = mttGetFieldNames(mtt_environment,'domain') ; is_anonymous = 0 ; if isempty(name.object) switch name.class case {'0','1'}, is_anonymous = 1 ; case 'SS', mttAssert(~isempty(name.object),... 'Anonymous "SS" object') ; otherwise, name.object = name.class ; end end if is_anonymous next = 1 + mttGetFieldLength(model,'anonymous') ; model.anonymous(next).class = name.class ; model.anonymous(next).xy = coordinates ; else object_names = mttGetFieldNames(model,'obj') ; if ~isempty(object_names) mttAssert(~ismember(name.object,object_names),... ['Repeated object: "',name.object,'"']) ; end switch name.class case {'0','1'}, mttValidateName(name.object) ; mttAssert(~ismember(name.object,{'in','out'}),... 'Junctions cannot use reserved port names') ; case {'SS','Se','Sf','De','Df'}, mttValidateName(name.object) ; if isempty(name.domain) | isempty(mtt_environment) model = setfield(model,'obj',name.object,'domain',[]) ; model = setfield(model,'obj',name.object,'domain_item',[]) ; else mttAssert(ismember(name.domain,domain_names),... ['Unrecognised domain "',name.domain,'"']) ; dom = getfield(mtt_environment,'domain',name.domain,'dom') ; item = getfield(mtt_environment,'domain',name.domain,'item') ; if isempty(item) public_domain = getfield(mtt_environment,'public_domain',{dom}) ; item_names = mttGetFieldNames(public_domain,'item') ; mttAssert(ismember(name.domain_item,item_names),... ['Item "',name.domain_item,'" not found in public domain "',name.domain,'"']) ; item_name = name.domain_item ; else mttAssert(isempty(name.domain_item),... ['Item unspecified in public domain "',name.domain,'"']) ; item_name = item ; end model = setfield(model,'obj',name.object,'domain',dom) ; model = setfield(model,'obj',name.object,'domain_item',item_name) ; end otherwise, mttValidateName(name.class) ; mttValidateName(name.object) ; mttAssert(~ismember(name.object,{'in','out'}),... 'Objects cannot use reserved port names') ; end model = setfield(model,'obj',name.object,'class',name.class) ; model = setfield(model,'obj',name.object,'xy',coordinates) ; end function model = incorporate_anonymous_objects(model) number_of_objects = mttGetFieldLength(model,'anonymous') ; last = length(num2str(number_of_objects)) ; for i = 1:last object_number(i) = '0' ; end for i = 1:number_of_objects anonymous_object = getfield(model,'anonymous',{i}) ; current_number = num2str(i) ; width = length(current_number) ; first = last-width+1 ; object_number(first:last) = current_number ; object_name = ['mtt_obj',object_number] ; model = setfield(model,'obj',object_name,model.anonymous(i)) ; end function r = sign_cross_product(v1,v2) r = sign(v1(1)*v2(2) - v1(2)*v2(1)) ; function model = identify_causal_assignments(model) L = mttGetFieldLength(model,'line') ; if L>0 N = mttGetFieldLength(model,'bond') ; for j = 1:L for i = 1:N s(i,j) = norm(model.line(j).mid - model.bond(i).xy1) ; f(i,j) = norm(model.line(j).mid - model.bond(i).xy2) ; end end [min_range_start,nearest_bond_start] = min(s) ; [min_range_finish,nearest_bond_finish] = min(f) ; equidistant = min_range_start==min_range_finish ; at_harpoon = min_range_start>min_range_finish ; for j = 1:L fulcrum = num2str(model.line(j).mid) ; mttAssert(~equidistant(j),... ['Ambiguous causal line at [',num2str(model.line(j).mid),']']) ; if at_harpoon(j) index = nearest_bond_finish(j) ; bond = model.bond(index) ; terminal = bond.xy2 ; terminal_vector = bond.v2 ; else index = nearest_bond_start(j) ; bond = model.bond(index) ; terminal = bond.xy1 ; terminal_vector = bond.v1 ; end to_lhs = norm(model.line(j).xy1 - terminal) ; to_mid = norm(model.line(j).mid - terminal) ; to_rhs = norm(model.line(j).xy2 - terminal) ; mttAssert(to_mid<norm(bond.harpoon),... ['Cannot assign causality at [',num2str(fulcrum),']']) ; causality_ok = 0 ; is_unicausal = to_mid<min(to_lhs,to_rhs) ; if is_unicausal [bond.flow,causality_ok] = mttAssign(bond.flow,at_harpoon(j)) ; [bond.effort,causality_ok] = mttAssign(bond.effort,at_harpoon(j)) ; else causal_vector = (right-left) * sign(to_mid>to_left) ; causal_assignment = sign_cross_product(terminal_vector,causal_vector) ; mttAssert(causal_assignment~=0,... ['Cannot determine causality near [',num2str(fulcrum),']']) ; if causal_assignment==bond.harpoon_side [bond.flow,causality_ok] = mttAssign(bond.flow,at_harpoon(j)) ; else [bond.effort,causality_ok] = mttAssign(bond.effort,at_harpoon(j)) ; end end mttAssert(causality_ok,... ['Ambiguous causal assignment near [',num2str(fulcrum),']']) ; bond.unicausal = mttCompare(bond.flow,bond.effort) ; model.bond(index) = bond ; end end function model = identify_object_binding(model) object_names = mttGetFieldNames(model,'obj') ; number_of_objects = length(object_names) ; number_of_bonds = mttGetFieldLength(model,'bond') ; for j = 1:number_of_bonds bond = model.bond(j) ; for i = 1:number_of_objects object = getfield(model,'obj',object_names{i}) ; origin_proximity(i) = norm(object.xy - bond.xy1) ; target_proximity(i) = norm(object.xy - bond.xy2) ; end [range,index] = min(origin_proximity) ; origin_name = object_names{index} ; bond.from.obj = origin_name ; bond.from.interface = [] ; [range,index] = min(target_proximity) ; target_name = object_names{index} ; bond.to.obj = target_name ; bond.to.interface = [] ; model = setfield(model,'bond',{j},bond) ; origin = getfield(model,'obj',origin_name) ; next = 1 + mttGetFieldLength(origin,'bond') ; origin.bond(next).number = j ; origin.bond(next).is_inbond = 0 ; model = setfield(model,'obj',origin_name,origin) ; target = getfield(model,'obj',target_name) ; next = 1 + mttGetFieldLength(target,'bond') ; target.bond(next).number = j ; target.bond(next).is_inbond = 1 ; model = setfield(model,'obj',target_name,target) ; end function model = identify_object_interfaces(model) object_names = mttGetFieldNames(model,'obj') ; number_of_objects = length(object_names) ; number_of_labels = mttGetFieldLength(model,'label') ; number_of_bonds = mttGetFieldLength(model,'bond') ; for j = 1:number_of_labels label = model.label(j) ; for i = 1:number_of_objects object_name = object_names{i} ; object = getfield(model,'obj',object_names{i}) ; proximity(i) = norm(object.xy - label.xy) ; end [range,index] = min(proximity) ; associated_object = object_names{index} ; object = getfield(model,'obj',associated_object) ; switch object.class case {'0','1'}, mttAssert(~label.is_inline,... ['Inline ports not valid for "0" and "1" junctions']) ; end next = 1 + mttGetFieldLength(object,'interface') ; object = setfield(object,'interface',{next},'name',label.name) ; object = setfield(object,'interface',{next},'class',[]) ; object = setfield(object,'interface',{next},'is_inline',label.is_inline) ; object = setfield(object,'interface',{next},'xy',label.xy) ; object = setfield(object,'interface',{next},'in',[]) ; object = setfield(object,'interface',{next},'out',[]) ; object = setfield(object,'interface',{next},'map',[]) ; model = setfield(model,'obj',associated_object,object) ; end for j = 1:number_of_objects object_name = object_names{j} ; object = getfield(model,'obj',object_name) ; number_of_attached_bonds = mttGetFieldLength(object,'bond') ; number_of_interfaces = mttGetFieldLength(object,'interface') ; for k = 1:number_of_interfaces interface = object.interface(k) ; inbond_proximity = [] ; inbond_counter = [] ; outbond_proximity = [] ; outbond_counter = [] ; in_counter = 0 ; out_counter = 0 ; for i = 1:number_of_attached_bonds bond_number = object.bond(i).number ; bond = model.bond(bond_number) ; if object.bond(i).is_inbond if isempty(bond.to.interface) in_counter = in_counter + 1 ; inbond_proximity(in_counter) = norm(interface.xy - bond.xy2) ; inbond_counter(in_counter) = bond_number ; end else if isempty(bond.from.interface) out_counter = out_counter + 1 ; outbond_proximity(out_counter) = norm(interface.xy - bond.xy1) ; outbond_counter(out_counter) = bond_number ; end end end [in_range,inbond_index] = min(inbond_proximity) ; [out_range,outbond_index] = min(outbond_proximity) ; inbond = inbond_counter(inbond_index) ; outbond = outbond_counter(outbond_index) ; if interface.is_inline mttAssert(~isempty(inbond_proximity),... ['No in-bond for interface "',object_name,'[',interface.name,']"']) ; mttAssert(~isempty(outbond_proximity),... ['No out-bond for interface "',object_name,'[',interface.name,']"']) ; interface.in = inbond ; interface.out = outbond ; model = setfield(model,'bond',{outbond},'from','interface',k) ; model = setfield(model,'bond',{inbond},'to','interface',k) ; else mttAssert(~(isempty(inbond_proximity) & isempty(outbond_proximity)),... ['No bond for interface "',object_name,'[',interface.name,']"']) ; if isempty(inbond_proximity) interface.out = outbond ; model = setfield(model,'bond',{outbond},'from','interface',k) ; elseif isempty(outbond_proximity) interface.in = inbond ; model = setfield(model,'bond',{inbond},'to','interface',k) ; else mttAssert(in_range~=out_range,... ['Ambiguous interface "',object_name,'[',interface.name,']"']) ; if out_range<in_range interface.out = outbond ; model = setfield(model,'bond',{outbond},'from','interface',k) ; else interface.in = inbond ; model = setfield(model,'bond',{inbond},'to','interface',k) ; end end end object.interface(k) = interface ; end model = setfield(model,'obj',object_name,object) ; end for i = 1:number_of_objects object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; number_of_interfaces = mttGetFieldLength(object,'interface') ; for k = 1:number_of_interfaces; interface = object.interface(k) ; if interface.is_inline mttAssert(~(isempty(interface.in) | isempty(interface.out)),... ['Unbound interface: ',object_name,'[',interface.name,']']) ; else mttAssert(~(isempty(interface.in) & isempty(interface.out)),... ['Unbound interface: ',object_name,'[',interface.name,']']) ; end end end objects_with_in = [] ; objects_with_out = [] ; for j = 1:number_of_bonds bond = model.bond(j) ; if isempty(bond.from.interface) object_name = bond.from.obj ; object = getfield(model,'obj',object_name) ; if ~ismember(object.class,{'0','1'}) mttAssert(~ismember(object_name,objects_with_out),... ['Object "',object_name,'" has more than one implicit out-bond']) ; if isempty(objects_with_out) objects_with_out = {object_name} ; else objects_with_out = [objects_with_out,{object_name}] ; end end next = 1 + mttGetFieldLength(object,'interface') ; model = setfield(model,'obj',object_name,'interface',{next},'name','out') ; model = setfield(model,'obj',object_name,'interface',{next},'in',[]) ; model = setfield(model,'obj',object_name,'interface',{next},'out',j) ; model = setfield(model,'bond',{j},'from','interface',next) ; end if isempty(bond.to.interface) object_name = bond.to.obj ; object = getfield(model,'obj',object_name) ; if ~ismember(object.class,{'0','1'}) mttAssert(~ismember(object_name,objects_with_in),... ['Object "',object_name,'" has more than one implicit in-bond']) ; if isempty(objects_with_in) objects_with_in = {object_name} ; else objects_with_in = [objects_with_in,{object_name}] ; end end next = 1 + mttGetFieldLength(object,'interface') ; model = setfield(model,'obj',object_name,'interface',{next},'name','in') ; model = setfield(model,'obj',object_name,'interface',{next},'in',j) ; model = setfield(model,'obj',object_name,'interface',{next},'out',[]) ; model = setfield(model,'bond',{j},'to','interface',next) ; end end function model = associate_external_domains(model) object_names = mttGetFieldNames(model,'obj') ; number_of_objects = length(object_names) ; for i = 1:number_of_objects object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; switch object.class case {'SS','Se','Sf','De','Df'}, mttAssert(mttGetFieldLength(object,'interface')==1,... ['Object "',object_name,'" must have a unique bond interface']) ; bond_number = [] ; if ~isempty(object.interface.in) bond_number = object.interface.in ; end if ~isempty(object.interface.out) bond_number = object.interface.out ; end [model,ok] = mttUpdateBondDomain(model,bond_number,object.domain,object.domain_item) ; mttAssert(ok,['Domain conflict on bond connected to object "',object_name,'"']) ; end end function model = tidy_up(model) % remove temperory data and xfig geometry from model structure object_names = mttGetFieldNames(model,'obj') ; number_of_objects = length(object_names) ; for i = 1:number_of_objects object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; object = mttDeleteField(object,'bond') ; object_interfaces = getfield(object,'interface') ; object_interfaces = mttDeleteField(object_interfaces,'is_inline') ; object_interfaces = mttDeleteField(object_interfaces,'xy') ; object = setfield(object,'interface',object_interfaces) ; object = mttDeleteField(object,'xy') ; model = setfield(model,'obj',object_name,object) ; end all_bonds = getfield(model,'bond') ; all_bonds = mttDeleteField(all_bonds,'xy1') ; all_bonds = mttDeleteField(all_bonds,'xy2') ; all_bonds = mttDeleteField(all_bonds,'v1') ; all_bonds = mttDeleteField(all_bonds,'v2') ; all_bonds = mttDeleteField(all_bonds,'harpoon') ; all_bonds = mttDeleteField(all_bonds,'harpoon_side') ; model = setfield(model,'bond',all_bonds) ; model = mttDeleteField(model,'anonymous') ; model = mttDeleteField(model,'line') ; model = mttDeleteField(model,'label') ; |
Added mttroot/ntt/bin/trans/m/mttFetchDomain.m version [3356e6dd33].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | function model = mttFetchDomain(filename) model.representation = 'domain' ; mttAssert(mttFileExists(filename),... ['File "',filename,'" not found']) ; mttNotify([' ...processing ',filename]) ; mttWriteNewLine ; model.source = mttCutText(filename,'_domain.txt') ; content = mttReadFile(filename) ; statements = mttExtractStatements(content) ; number_of_statements = length(statements) ; next = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case {'domain','public_domain','private_domain'}, domain_name = line ; mttValidateName(domain_name) ; [domain,next] = fetch_domain(statements,next,domain_name) ; model = setfield(model,'item',domain_name,domain) ; is_private = strcmp(keyword,'private_domain') ; model = setfield(model,'item',domain_name,'is_private',is_private) ; case {'multi_domain','public_multi_domain','private_multi_domain'}, domain_name = line ; mttValidateName(domain_name) ; [domain,next] = fetch_multi_domain(statements,next,domain_name) ; model = setfield(model,'item',domain_name,domain) ; is_private = strcmp(keyword,'private_multi_domain') ; model = setfield(model,'item',domain_name,'is_private',is_private) ; case '{', error('Unexpected "{" found') ; case '}', error('Unexpected "}" found') ; otherwise, error(['Unrecognised top-level keyword "',keyword,'"']) ; end if next==number_of_statements parsing = 0 ; end end function [domain,next] = fetch_domain(statements,next,domain_name) domain = [] ; unit_name = 'domain' ; number_of_statements = length(statements) ; effort_declared = 0 ; flow_declared = 0 ; open = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'effort', mttAssert(open,... ['"effort" declarations must be contained inside {...} in "',unit_name,'"']) ; mttAssert(~effort_declared,... ['"effort" declarations must be unique in "',unit_name,'"']) ; mttAssert(~isempty(line),... ['Undefined "effort" in "',unit_name,'"']) ; [covar,default] = mttCutText(line,'=') ; mttValidateName(covar) ; domain.covar.effort = covar ; domain.covar.effort_default = default ; effort_declared = 1 ; case 'flow', mttAssert(open,... ['"flow" declarations must be contained inside {...} in "',unit_name,'"']) ; mttAssert(~flow_declared,... ['"flow" declarations must be unique in "',unit_name,'"']) ; mttAssert(~isempty(line),... ['Undefined "flow" in "',unit_name,'"']) ; [covar,default] = mttCutText(line,'=') ; mttValidateName(covar) ; domain.covar.flow = covar ; domain.covar.flow_default = default ; flow_declared = 1 ; case '{', mttAssert(~open,['Unmatched "{" in "',unit_name,'"']) ; open = 1 ; case '}', mttAssert(open,['Unmatched "}" in "',unit_name,'"']) ; open = 0 ; otherwise, error(['Unrecognised_keyword "',keyword,'" in "',unit_name,'"']) ; end mttAssert(~(open & (next==number_of_statements)),... ['Missing "}" in "',unit_name,'"']) ; if (~open) | (next==number_of_statements) parsing = 0 ; end end function [domain,next] = fetch_multi_domain(statements,next,domain_name) domain = [] ; unit_name = 'domain' ; number_of_statements = length(statements) ; counter = 0 ; open = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'bond', mttAssert(open,... ['"bond" declarations must be contained inside {...} in "',unit_name,'"']) ; mttAssert(~isempty(line),... ['Undefined "bond" in "',unit_name,'"']) ; [bond_name,bond_domain] = mttCutText(line,'[') ; [bond_domain,rubbish] = mttCutText(bond_domain,']') ; mttAssert(isempty(rubbish),... ['Unexpected text after "]" in "',unit_name,'"']) ; if ~isempty(bond_name) mttValidateName(bond_name) ; end counter = counter + 1 ; domain.bond(counter).name = bond_name ; domain.bond(counter).domain = bond_domain ; case '{', mttAssert(~open,['Unmatched "{" in "',unit_name,'"']) ; open = 1 ; case '}', mttAssert(open,['Unmatched "}" in "',unit_name,'"']) ; open = 0 ; otherwise, error(['Unrecognised_keyword "',keyword,'" in "',unit_name,'"']) ; end mttAssert(~(open & (next==number_of_statements)),... ['Missing "}" in "',unit_name,'"']) ; if (~open) | (next==number_of_statements) parsing = 0 ; end end |
Added mttroot/ntt/bin/trans/m/mttFetchEnvironment.m version [43e7bb5007].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 | function model = mttFetchEnvironment(filename) model.representation = 'env' ; mttAssert(mttFileExists(filename),... ['File "',filename,'" not found']) ; mttNotify([' ...processing ',filename]) ; mttWriteNewLine ; model.source = mttCutText(filename,'_env.txt') ; model_name = mttDetachText(model.source,'/') ; content = mttReadFile(filename) ; statements = mttExtractStatements(content) ; number_of_statements = length(statements) ; env_declared = 0 ; next = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'env', mttAssert(~env_declared,... '"env" declaration must be unique') ; env_declared = 1 ; env_name = line ; mttAssert(strcmp(env_name,model_name),... ['Wrong name:[',env_name,'] Expecting:[',model_name,']']) ; [env,next] = fetch_env(statements,next) ; model = mttAppendFields(model,env) ; case '{', error('Unexpected "{" found') ; case '}', error('Unexpected "}" found') ; otherwise, error(['Unrecognised top-level keyword "',keyword,'"']) ; end if next==number_of_statements parsing = 0 ; end end function [env,next] = fetch_env(statements,next) env = [] ; unit_name = 'env' ; number_of_statements = length(statements) ; open = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'path', mttAssert(open,... ['"path" declarations must be contained inside {...} in "',unit_name,'"']) ; path_names = mttGetFieldNames(env,'path') ; [path_name,path_spec] = mttCutText(line,':=') ; mttAssert(~ismember(path_name,path_names),... ['Path "',path_name,'" already declared']) ; mttAssert(path_name(1)=='$',... ['Path "',path_name,'" must be prefixed with "$"']) ; path_name(1) = [] ; env = setfield(env,'path',path_name,path_spec) ; case 'domain', mttAssert(open,... ['"domain" declarations must be contained inside {...} in "',unit_name,'"']) ; domain_names = mttGetFieldNames(env,'domain') ; [domain_name,domain_spec] = mttCutText(line,':=') ; mttAssert(~ismember(domain_name,domain_names),... ['Domain "',domain_name,'" already declared']) ; env = setfield(env,'domain',domain_name,domain_spec) ; case 'struct', mttAssert(open,... ['"struct" declarations must be contained inside {...} in "',unit_name,'"']) ; struct_names = mttGetFieldNames(env,'struct') ; [struct_name,struct_spec] = mttCutText(line,':=') ; mttAssert(~ismember(struct_name,struct_names),... ['Struct "',struct_name,'" already declared']) ; mttAssert(~isempty(struct_spec),... ['Undefined datatype within struct "',struct_name,'"']) ; env = setfield(env,'struct',struct_name,struct_spec) ; case '{', mttAssert(~open,['Unmatched "{" in "',unit_name,'"']) ; open = 1 ; case '}', mttAssert(open,['Unmatched "}" in "',unit_name,'"']) ; open = 0 ; otherwise, error(['Unrecognised_keyword "',keyword,'" in "',unit_name,'"']) ; end mttAssert(~(open & (next==number_of_statements)),... ['Missing "}" in "',unit_name,'"']) ; if (~open) | (next==number_of_statements) parsing = 0 ; end end env = mttSetFieldDefault(env,'path',[]) ; env = mttSetFieldDefault(env,'domain',[]) ; env = mttSetFieldDefault(env,'struct',[]) ; |
Added mttroot/ntt/bin/trans/m/mttFetchInterfaceDefinition.m version [317a4da97c].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 | function model = mttFetchInterfaceDefinition(filename) mttAssert(exist(filename)==2,... ['File "',filename,'" not found']) ; mttNotify([' ...processing ',filename]) ; mttWriteNewLine ; model.representation = 'cr' ; model.source = mttCutText(filename,'_cr.txt') ; content = mttReadFile(filename) ; statements = mttExtractStatements(content) ; number_of_statements = length(statements) ; crs = [] ; next = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'cr', cr_name = mttCutText(line,'[') ; mttValidateName(cr_name) ; if ~isempty(crs) mttAssert(~ismember(cr_name,crs),... ['"cr ',cr_name,'" has already been declared']) ; end cr_parameter_list = mttExtractText(line,'[',']') ; [cr_parameters,cr_defaults] = mttGetParameters(cr_parameter_list) ; [cr,next] = fetch_cr(statements,next,cr_name,cr_parameters,cr_defaults) ; mttCheckInterfaceDeclarations(cr) ; mttCheckStateDeclarations(cr) ; model = setfield(model,'item',cr_name,cr) ; if isempty(crs) crs = {cr_name} ; else crs = [crs,{cr_name}] ; end case '{', error('Unexpected "{" found') ; case '}', error('Unexpected "}" found') ; otherwise, error(['Unrecognised top-level keyword "',keyword,'"']) ; end if next==number_of_statements parsing = 0 ; end end function [cr,next] = fetch_cr(statements,next,cr_name,cr_parameters,cr_defaults) unit_name = 'cr' ; here = [cr_name,'/',unit_name] ; cr = [] ; number_of_statements = length(statements) ; cr.sympar = cr_parameters ; cr.numpar = [] ; cr.input = [] ; cr.state = [] ; cr.sympar_default = cr_defaults ; cr.numpar_default = [] ; cr.input_default = [] ; cr.state_default = [] ; op_counter = 0 ; interface_declared = 0 ; open = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'interface', mttAssert(open,... ['"interface" declaration must be contained inside {...} in ',here]) ; mttAssert(~interface_declared,... '"interface" declaration must be unique') ; mttAssert(isempty(line),... ['Unexpected text after "interface" declaration in ',here]) ; [interface,next] = fetch_interface(statements,next,cr_name) ; cr.interface = interface ; interface_declared = 1 ; case 'operator', mttAssert(interface_declared,... ['"operator" declaration must follow "interface" in ',here]) ; mttAssert(open,... ['"operator" declaration must be contained inside {...} in ',here]) ; op_counter = op_counter + 1 ; [operator,next] = fetch_operator(statements,next,cr,cr_name) ; if ~isfield(operator,'content') operator.content = [] ; end cr.operator(op_counter) = operator ; case 'input', mttAssert(open,... ['"input" declarations must be contained inside {...} in ',here]) ; input_parameter_list = line ; [input_parameters,input_defaults] = mttGetParameters(input_parameter_list) ; cr = mttAppend(cr,'input',input_parameters) ; cr = mttAppend(cr,'input_default',input_defaults) ; case 'numpar', mttAssert(open,... ['"numpar" declarations must be contained inside {...} in ',here]) ; numerical_parameter_list = line ; [numerical_parameters,numerical_defaults] = mttGetParameters(numerical_parameter_list) ; cr = mttAppend(cr,'numpar',numerical_parameters) ; cr = mttAppend(cr,'numpar_default',numerical_defaults) ; case 'state', mttAssert(open,... ['"state" declarations must be contained inside {...} in ',here]) ; state_parameter_list = line ; [state_parameters,state_defaults] = mttGetParameters(state_parameter_list) ; cr = mttAppend(cr,'state',state_parameters) ; cr = mttAppend(cr,'state_default',state_defaults) ; case '{', mttAssert(~open,['Unmatched "{" in ',here]) ; open = 1 ; case '}', mttAssert(open,['Unmatched "}" in ',here]) ; open = 0 ; otherwise, error(['Unrecognised keyword "',keyword,'" in ',here]) ; end mttAssert(~(open & (next==number_of_statements)),... ['Missing "}" in ',here]) ; if (~open) | (next==number_of_statements) parsing = 0 ; end end interface_ports = mttGetFieldNames(cr.interface,'port') ; interface_ports_with_state = [] ; counter = 0 ; for i = 1:length(interface_ports) port_name = interface_ports{i} ; interface_port = getfield(cr.interface,'port',port_name) ; if interface_port.is_effort_state | interface_port.is_flow_state counter = counter + 1 ; interface_ports_with_state{counter} = port_name ; end end mttAssert(op_counter>0,... ['No operator defined in ',here]) ; assigned_ports = [] ; for i = 1:length(cr.operator) if i==1 operator_names{1} = cr.operator(i).name ; else operator_name = cr.operator(i).name ; mttAssert(~ismember(operator_name,operator_names),... ['Repeated operator name "',operator_name,'" in ',here]) ; operator_names{i} = operator_name ; end newly_assigned_ports = mttGetFieldNames(cr.operator(i),'assign') ; if isempty(assigned_ports) assigned_ports = newly_assigned_ports ; else if ~isempty(newly_assigned_ports) assigned_ports = [assigned_ports, newly_assigned_ports] ; end end end for i = 1:length(interface_ports_with_state) interface_port = interface_ports_with_state{i} ; mttAssert(ismember(interface_port,assigned_ports),... ['Missing "set" declaration for port "',interface_port,'" in ',here]) ; end function [interface,next] = fetch_interface(statements,next,cr_name) global mtt_environment unit_name = 'interface' ; here = [cr_name,'/',unit_name] ; domain_names = mttGetFieldNames(mtt_environment,'domain') ; interface = [] ; number_of_statements = length(statements) ; counter = 0 ; constraint = [] ; open = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'port', ports = mttGetItemList(line) ; for n = 1:length(ports) identifier = mttCutText(ports{n},'[') ; qualifier = mttExtractText(ports{n},'[',']') ; [name.domain,name.domain_item] = mttCutText(qualifier,'::') ; name.port = identifier ; mttValidateName(name.port) ; if isempty(name.domain) | isempty(mtt_environment) interface = setfield(interface,'port',name.port,'domain',[]) ; interface = setfield(interface,'port',name.port,'domain_item',[]) ; interface = setfield(interface,'port',name.port,'was_generic',1) ; else mttAssert(ismember(name.domain,domain_names),... ['Unrecognised domain "',name.domain,'"']) ; dom = getfield(mtt_environment,'domain',name.domain,'dom') ; item = getfield(mtt_environment,'domain',name.domain,'item') ; if isempty(item) public_domain = getfield(mtt_environment,'public_domain',{dom}) ; item_names = mttGetFieldNames(public_domain,'item') ; mttAssert(ismember(name.domain_item,item_names),... ['Item "',name.domain_item,'" not found in public domain "',name.domain,'"']) ; item_name = name.domain_item ; else mttAssert(isempty(name.domain_item),... ['Item unspecified in public domain "',name.domain,'"']) ; item_name = item ; end interface = setfield(interface,'port',name.port,'domain',dom) ; interface = setfield(interface,'port',name.port,'domain_item',item_name) ; interface = setfield(interface,'port',name.port,'was_generic',0) ; end interface = setfield(interface,'port',name.port,'is_effort_state',0) ; interface = setfield(interface,'port',name.port,'is_flow_state',0) ; interface = setfield(interface,'port',name.port,'assign',[]) ; end case {'assert','prefer'}, counter = counter + 1 ; constraint{counter} = statement ; case '{', mttAssert(~open,['Unmatched "{" in ',here]) ; open = 1 ; case '}', mttAssert(open,['Unmatched "}" in ',here]) ; open = 0 ; otherwise, error(['Unrecognised_keyword "',keyword,'" in ',here]) ; end mttAssert(~(open & (next==number_of_statements)),... ['Missing "}" in ',here]) ; if (~open) | (next==number_of_statements) parsing = 0 ; end end interface_ports = mttGetFieldNames(interface,'port') ; number_of_constraints = length(constraint) ; for i = 1:number_of_constraints [keyword,assignment] = mttSeparateText(constraint{i}) ; [namelist,definition] = mttCutText(assignment,'=>') ; mttAssert(~isempty(keyword),... ['Rule "',constraint{i},'" has no context in cr ',cr_name]) ; if ~isempty(namelist) first = 1 ; last = length(namelist) ; if namelist([first,last])=='[]' ports = mttGetItemList(mttExtractText(namelist,'[',']')) ; else ports = {namelist} ; end end mttAssert(~isempty(ports),... ['Rule "',constraint{i},'" has no association in cr ',cr_name]) ; mttAssert(~isempty(definition),... ['Rule "',constraint{i},'" not defined in cr ',cr_name]) ; for j = 1:length(ports) port_name = ports{j} ; mttValidateName(port_name) ; other_ports = [] ; counter = 0 ; for k = 1:length(ports) if j~=k counter = counter + 1 ; other_ports{counter} = ports{k} ; end end mttAssert(ismember(port_name,interface_ports),... ['Unreferenced port "',port_name,'" in cr ',cr_name]) ; port = getfield(interface,'port',port_name) ; switch definition case 'effort_state', mttAssert(mttIsEqual(port.is_flow_state,0),... ['Attempt to overwrite state assignment at port "',port_name,'" in ',here]) ; port.is_effort_state = 1 ; case 'flow_state', mttAssert(mttIsEqual(port.is_effort_state,0),... ['Attempt to overwrite state assignment at port "',port_name,'" in ',here]) ; port.is_flow_state = 1 ; otherwise, rule_number = 1 + mttGetFieldLength(port,'causality') ; port.causality(rule_number).rule = keyword ; port.causality(rule_number).def = definition ; port.causality(rule_number).with = other_ports ; port.causality(rule_number).applied = 0 ; end interface = setfield(interface,'port',port_name,port) ; end end function [operator,next] = fetch_operator(statements,next,cr,cr_name) unit_name = 'operator' ; here = [cr_name,'/',unit_name] ; interface = [] ; number_of_statements = length(statements) ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; operator = mttGetOperatorContext(line,cr,cr_name) ; operator.content = [] ; operator.var = [] ; operator.var_default = [] ; operator.struct = [] ; operator.set = [] ; counter = 0 ; open = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case '{', mttAssert(~open,['Unmatched "{" in ',here]) ; open = 1 ; case '}', mttAssert(open,['Unmatched "}" in ',here]) ; open = 0 ; case 'set', mttAssert(open,... ['"set" declarations must be contained inside {...} in ',here]) ; operator = mttAppend(operator,'set',{line}) ; case 'var', mttAssert(open,... ['"var" declarations must be contained inside {...} in ',here]) ; variable_list = line ; [variables,defaults] = mttGetParameters(variable_list) ; operator = mttAppend(operator,'var',variables) ; operator = mttAppend(operator,'var_default',defaults) ; case 'struct', mttAssert(open,... ['"struct" declarations must be contained inside {...} in ',here]) ; [struct_name,variable_list] = mttSeparateText(line) ; [variables,defaults] = mttGetParameters(variable_list) ; mttAssert(mttIsEmptyCellArray(defaults),... ['"struct" declarations cannot have default values in ',here]) ; operator.struct = mttAppend(operator.struct,struct_name,variables) ; otherwise, counter = counter + 1 ; operator.content{counter} = statement ; end mttAssert(~(open & (next==number_of_statements)),... ['Missing "}" in ',here]) ; if (~open) | (next==number_of_statements) parsing = 0 ; end end cr_ports = mttGetFieldNames(cr.interface,'port') ; for i = 1:length(operator.var) current_var = operator.var{i} ; mttAssert(~ismember(current_var,cr.numpar),... ['Variable "',current_var,'" redeclares CR numerical parameter in ',cr_name]) ; mttAssert(~ismember(current_var,cr.sympar),... ['Variable "',current_var,'" redeclares CR parameter in ',cr_name]) ; mttAssert(~ismember(current_var,cr_ports),... ['Variable "',current_var,'" redeclares CR port in ',cr_name]) ; end operator = mttParseOperatorEquations(operator,cr,cr_name) ; function context = mttGetOperatorContext(line,cr,cr_name) index = sort([findstr(line,'|'),findstr(line,'<'),findstr(line,'>')]) ; assignment = findstr(line,':=') ; mttAssert(length(assignment)==1,... ['Operator declaration must contain a unique ":=" assignment in cr ',cr_name]) ; mttAssert(length(index)>0,... ['Operator declaration without ports in cr ',cr_name]) ; left_side = index(index<assignment) ; right_side = index(index>assignment) ; mttAssert(length(left_side)>0,... ['Operator declaration without input ports in cr ',cr_name]) ; mttAssert(length(right_side)>0,... ['Operator declaration without output ports in cr ',cr_name]) ; mttAssert(mod(length(left_side),2)==0 & mod(length(right_side),2)==0,... ['Operator declaration has mismatched tags in cr ',cr_name]) ; context.name = mttClipText(line(assignment+2:right_side(1)-1)) ; mttAssert(~isempty(context.name),... ['Operator declaration is anonymous in cr ',cr_name]) ; mttValidateName(context.name) ; counter = 0 ; for i = 1:length(index)/2 counter = counter + 1 ; link = [] ; right = 2*i ; left = right - 1 ; if index(right)<assignment link.is_input = 0 ; elseif index(left)>assignment link.is_input = 1 ; end recognised = 1 ; switch line(index([left,right])) case '|>', link.is_flow = 1 ; link.is_effort = 0 ; case '<|', link.is_flow = 0 ; link.is_effort = 1 ; case '<>', link.is_flow = 1 ; link.is_effort = 1 ; otherwise, recognised = 0 ; end mttAssert(recognised,... ['Unrecognised tags in operator ',context.name,' (cr ',cr_name,')']) ; port_declaration = line(index(left):index(right)) ; port = line(index(left)+1:index(right)-1) ; mttAssert(~isempty(port),... ['Empty port in operator ',context.name,' (cr ',cr_name,')']) ; [port_name,qualifier] = mttCutText(port,'=') ; link.name = port_name ; if isempty(qualifier) link.is_unconstrained = 1 ; else link.is_unconstrained = 0 ; mttAssert(strcmp(qualifier,'0'),... ['Non-zero port constraint in operator ',context.name,' (cr ',cr_name,')']) ; end context.link(counter) = link ; end cr_port_names = mttGetFieldNames(cr.interface,'port') ; check.is_input = [] ; check.is_output = [] ; check.is_effort = [] ; check.is_flow = [] ; for j = 1:length(cr_port_names) port_check(j) = check ; end for i = 1:counter port_name = context.link(i).name ; mttAssert(ismember(port_name,cr_port_names),... ['Operator declaration uses undefined port "',port_name,'" in cr ',cr_name]) ; index = strmatch(port_name,cr_port_names,'exact') ; mttAssert(~mttIsEqual(port_check(index).is_input,context.link(i).is_input),... ['Operator declaration has repeated input ports in cr ',cr_name]) ; mttAssert( mttIsEqual(port_check(index).is_output,context.link(i).is_input),... ['Operator declaration has repeated output ports in cr ',cr_name]) ; mttAssert(~mttIsEqual(port_check(index).is_flow,context.link(i).is_flow),... ['Operator declaration has repeated flow in cr ',cr_name]) ; mttAssert(~mttIsEqual(port_check(index).is_effort,context.link(i).is_effort),... ['Operator declaration has repeated effort in cr ',cr_name]) ; port_check(index).is_input = context.link(i).is_input ; port_check(index).is_output = ~context.link(i).is_input ; port_check(index).is_flow = context.link(i).is_flow ; port_check(index).is_effort = context.link(i).is_effort ; end for j = 1:length(cr_port_names) mttAssert(~isempty(port_check(j).is_input),... ['Operator declaration has missing input ports in cr ',cr_name]) ; mttAssert(~isempty(port_check(j).is_output),... ['Operator declaration has missing output ports in cr ',cr_name]) ; mttAssert(~isempty(port_check(j).is_flow),... ['Operator declaration has missing flow in cr ',cr_name]) ; mttAssert(~isempty(port_check(j).is_effort),... ['Operator declaration has missing effort in cr ',cr_name]) ; end |
Added mttroot/ntt/bin/trans/m/mttFetchSpecification.m version [94b1cb9964].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | function model = mttFetchSpecification(filename) model = [] ; mttAssert(mttFileExists(filename),... ['File "',filename,'" not found']) ; mttNotify([' ...processing ',filename]) ; mttWriteNewLine ; model.specification = filename ; model.source = mttCutText(filename,'_abg.txt') ; model_name = mttDetachText(model.source,'/') ; content = mttReadFile(filename) ; statements = mttExtractStatements(content) ; number_of_statements = length(statements) ; abg_declared = 0 ; next = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'abg', mttAssert(~abg_declared,... '"abg" declaration must be unique') ; abg_declared = 1 ; abg_name = mttCutText(line,'[') ; mttAssert(strcmp(abg_name,model_name),... ['Wrong name:[',abg_name,'] Expecting:[',model_name,']']) ; abg_parameter_list = mttExtractText(line,'[',']') ; [abg_parameters,abg_defaults] = mttGetParameters(abg_parameter_list) ; model.name = abg_name ; model.sympar = abg_parameters ; model.sympar_default = abg_defaults ; [abg,next] = fetch_abg(statements,next) ; model = mttAppendFields(model,abg) ; case '{', error('Unexpected "{" found') ; case '}', error('Unexpected "}" found') ; otherwise, error(['Unrecognised top-level keyword "',keyword,'"']) ; end if next==number_of_statements parsing = 0 ; end end mttCheckBondgraphDeclarations(model) ; function [abg,next] = fetch_abg(statements,next) global mtt_environment abg = [] ; unit_name = 'abg' ; user_defined_paths = mttGetFieldNames(mtt_environment,'path') ; number_of_statements = length(statements) ; bondgraph = [] ; use_declared = 0 ; open = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'use', mttAssert(open,... ['"use" declaration must be contained inside {...} in "',unit_name,'"']) ; mttAssert(~use_declared,... '"use" declaration must be unique') ; use_declared = 1 ; bondgraph = line ; abg.bondgraph = bondgraph ; case 'input', mttAssert(open,... ['"input" declarations must be contained inside {...} in "',unit_name,'"']) ; input_parameter_list = line ; [input_parameters,input_defaults] = mttGetParameters(input_parameter_list) ; abg = mttAppend(abg,'input',input_parameters) ; abg = mttAppend(abg,'input_default',input_defaults) ; case 'numpar', mttAssert(open,... ['"numpar" declarations must be contained inside {...} in "',unit_name,'"']) ; numerical_parameter_list = line ; [numerical_parameters,numerical_defaults] = mttGetParameters(numerical_parameter_list) ; abg = mttAppend(abg,'numpar',numerical_parameters) ; abg = mttAppend(abg,'numpar_default',numerical_defaults) ; case 'object', mttAssert(open,... ['"object" declarations must be contained inside {...} in "',unit_name,'"']) ; object_names = mttGetFieldNames(abg,'obj') ; [object_name,object_spec] = mttCutText(line,':=') ; mttAssert(~ismember(object_name,object_names),... ['Object "',object_name,'" already declared']) ; implementation = mttCutText(object_spec,'[') ; mttAssert(~isempty(implementation),... ['Incomplete specification:[',line,']']) ; object_parameter_list = mttExtractText(line,'[',']') ; object_parameters = mttGetInstanceParameters(object_parameter_list) ; [source,name.item] = mttCutText(implementation,'::') ; [name.class,name.path] = mttDetachText(source,'/') ; if isempty(name.class) name.class = source ; name.path = [] ; else mttAssert(~isempty(name.path),... ['Empty path name in "',unit_name,'"']) ; if name.path(1)=='$' [path_alias,path_branch] = mttCutText(name.path,'/') ; path_alias(1) = [] ; mttAssert(ismember(path_alias,user_defined_paths),... ['Path "',path_alias,'" not recognised']) ; path_root = getfield(mtt_environment,'path',path_alias) ; if isempty(path_branch) name.path = path_root ; else name.path = [path_root,'/',path_branch] ; end end end abg = setfield(abg,'obj',object_name,'name',name) ; abg = setfield(abg,'obj',object_name,'parameter',object_parameters) ; case '{', mttAssert(~open,['Unmatched "{" in "',unit_name,'"']) ; open = 1 ; case '}', mttAssert(open,['Unmatched "}" in "',unit_name,'"']) ; open = 0 ; otherwise, error(['Unrecognised_keyword "',keyword,'" in "',unit_name,'"']) ; end mttAssert(~(open & (next==number_of_statements)),... ['Missing "}" in "',unit_name,'"']) ; if (~open) | (next==number_of_statements) parsing = 0 ; end end abg = mttSetFieldDefault(abg,'input',[]) ; abg = mttSetFieldDefault(abg,'input_default',[]) ; abg = mttSetFieldDefault(abg,'numpar',[]) ; abg = mttSetFieldDefault(abg,'numpar_default',[]) ; abg = mttSetFieldDefault(abg,'bondgraph',[]) ; |
Added mttroot/ntt/bin/trans/m/mttFetchStruct.m version [3e806bb24f].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | function model = mttFetchStruct(filename) model.representation = 'struct' ; mttAssert(mttFileExists(filename),... ['File "',filename,'" not found']) ; mttNotify([' ...processing ',filename]) ; mttWriteNewLine ; model.source = mttCutText(filename,'_struct.txt') ; content = mttReadFile(filename) ; statements = mttExtractStatements(content) ; number_of_statements = length(statements) ; next = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case {'struct','public_struct','private_struct'}, struct_name = line ; mttValidateName(struct_name) ; [struct,next] = fetch_struct(statements,next,struct_name) ; model = setfield(model,'item',struct_name,struct) ; is_private = strcmp(keyword,'private_struct') ; model = setfield(model,'item',struct_name,'is_private',is_private) ; case '{', error('Unexpected "{" found') ; case '}', error('Unexpected "}" found') ; otherwise, error(['Unrecognised top-level keyword "',keyword,'"']) ; end if next==number_of_statements parsing = 0 ; end end function [struct,next] = fetch_struct(statements,next,struct_name) struct = [] ; unit_name = 'struct' ; number_of_statements = length(statements) ; counter = 0 ; open = 0 ; parsing = 1 ; while parsing next = next + 1 ; statement = statements{next} ; [keyword,line] = mttSeparateText(statement) ; switch keyword case 'var', mttAssert(open,... ['"var" declarations must be contained inside {...} in "',unit_name,'"']) ; mttAssert(~isempty(line),... ['Undefined "var" in "',unit_name,'"']) ; data_name = line ; mttValidateName(data_name) ; counter = counter + 1 ; struct.var(counter).name = data_name ; struct.var(counter).type = [] ; case '{', mttAssert(~open,['Unmatched "{" in "',unit_name,'"']) ; open = 1 ; case '}', mttAssert(open,['Unmatched "}" in "',unit_name,'"']) ; open = 0 ; otherwise, mttAssert(open,... ['Declarations must be contained inside {...} in "',unit_name,'"']) ; mttAssert(~isempty(line),... ['Empty declaration in "',unit_name,'"']) ; data_name = line ; mttValidateName(data_name) ; data_type = keyword ; mttValidateName(data_type) ; counter = counter + 1 ; struct.var(counter).name = data_name ; struct.var(counter).type = data_type ; end mttAssert(~(open & (next==number_of_statements)),... ['Missing "}" in "',unit_name,'"']) ; if (~open) | (next==number_of_statements) parsing = 0 ; end end |
Added mttroot/ntt/bin/trans/m/mttIdentifyDomainCovariables.m version [9da7d7b8fd].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 | function compound_item = mttIdentifyDomainCovariables(item,domain,model) domains = mttGetFieldNames(model,'domain') ; domain_name = domain.source ; domain_shortname = mttDetachText(domain_name,'/') ; item_names = mttGetFieldNames(domain,'item') ; number_of_bonds = mttGetFieldLength(item,'bond') ; if number_of_bonds==0 compound_item.effort = {item.covar.effort} ; compound_item.flow = {item.covar.flow} ; compound_item.effort_default = {item.covar.effort_default} ; compound_item.flow_default = {item.covar.flow_default} ; else counter = 0 ; for k = 1:number_of_bonds bond = item.bond(k) ; [next_domain,next_item] = mttCutText(bond.domain,'::') ; if isempty(next_item) mttAssert(ismember(next_item,item_names),... ['Unrecognised reference "',next_item,'" in domain ',domain_shortname]) ; next_item = bond.domain ; dependent_item = getfield(domain,'item',next_item) ; compound_domain = mttIdentifyDomainCovariables(dependent_item,domain,model) ; else mttAssert(ismember(next_domain,domains),... ['Unrecognised domain reference "',next_domain,'" in domain ',domain_shortname]) ; next_domain_index = getfield(model,'domain',next_domain,'dom') ; next_domain_item_reference = getfield(model,'domain',next_domain,'item') ; mttAssert(isempty(next_domain_item_reference),... ['Constrained domain reference "',next_domain,'" in domain ',domain_shortname]) ; actual_domain = model.dom(next_domain_index) ; actual_domain_name = actual_domain.source ; actual_domain_shortname = mttDetachText(actual_domain_name,'/') ; actual_item_names = mttGetFieldNames(actual_domain,'item') ; mttAssert(ismember(next_item,actual_item_names),... ['Unrecognised reference "',next_item,'" in domain ',actual_domain_shortname]) ; dependent_item = getfield(actual_domain,'item',next_item) ; mttAssert(~dependent_item.is_private,... ['No public cross-reference available for "',next_item,'" in domain ',actual_domain_shortname]) ; compound_domain = mttIdentifyDomainCovariables(dependent_item,actual_domain,model) ; end for i = 1:length(compound_domain.effort) counter = counter + 1 ; if isempty(bond.name) compound_effort{counter} = compound_domain.effort{i} ; compound_flow{counter} = compound_domain.flow{i} ; else compound_effort{counter} = [bond.name,'.',compound_domain.effort{i}] ; compound_flow{counter} = [bond.name,'.',compound_domain.flow{i}] ; end compound_effort_default{counter} = compound_domain.effort_default{i} ; compound_flow_default{counter} = compound_domain.flow_default{i} ; end end depth = length(compound_effort) ; for n = 1:depth-1 mttAssert(~ismember(compound_effort{n},{compound_effort{n+1:depth}}),... ['Repeated effort variable "',compound_effort{n},'" in domain ',domain_shortname]) ; mttAssert(~ismember(compound_flow{n},{compound_flow{n+1:depth}}),... ['Repeated flow variable "',compound_flow{n},'" in domain ',domain_shortname]) ; end for n = 1:depth mttAssert(~ismember(compound_effort{n},{compound_flow{1:depth}}),... ['Ambiguous effort/flow variable "',compound_effort{n},'" in domain ',domain_shortname]) ; mttAssert(~ismember(compound_flow{n},{compound_effort{1:depth}}),... ['Ambiguous flow/effort variable "',compound_flow{n},'" in domain ',domain_shortname]) ; end mttAssert(~ismember('flow',{compound_effort{1:depth}}),... ['Effort variable called "flow" in domain ',domain_shortname]) ; mttAssert(~ismember('effort',{compound_flow{1:depth}}),... ['flow variable called "effort" in domain ',domain_shortname]) ; compound_item.effort = compound_effort ; compound_item.flow = compound_flow ; compound_item.effort_default = compound_effort_default ; compound_item.flow_default = compound_flow_default ; end |
Added mttroot/ntt/bin/trans/m/mttIdentifyStructVariables.m version [69b4827ac5].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | function compound_item = mttIdentifyStructVariables(item,struct,model) structs = mttGetFieldNames(model,'struct') ; struct_name = struct.source ; struct_shortname = mttDetachText(struct_name,'/') ; item_names = mttGetFieldNames(struct,'item') ; number_of_vars = mttGetFieldLength(item,'var') ; counter = 0 ; for k = 1:number_of_vars var = item.var(k) ; next_item = var.type ; if isempty(next_item) counter = counter + 1 ; compound_var{counter} = var.name ; else mttAssert(ismember(next_item,item_names),... ['Unrecognised reference "',next_item,'" in struct ',struct_shortname]) ; dependent_item = getfield(struct,'item',next_item) ; compound_struct = mttIdentifyStructVariables(dependent_item,struct,model) ; for i = 1:length(compound_struct.var) counter = counter + 1 ; compound_var{counter} = [var.name,'.',compound_struct.var{i}] ; end end variables = length(compound_var) ; for n = 1:variables-1 ; mttAssert(~ismember(compound_var{n},{compound_var{n+1:variables}}),... ['Repeated variable "',compound_var{n},'" in struct ',struct_shortname]) ; end compound_item.var = compound_var ; end |
Added mttroot/ntt/bin/trans/m/mttParseOperatorEquations.m version [aba93f30d1].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 | function operator = mttParseOperatorEquations(operator,cr,cr_name) global mtt_environment operator.equation = [] ; % operator.is_used = 0 ; numparlist = cr.numpar ; symparlist = cr.sympar ; varlist = operator.var ; inputlist = cr.input ; statelist = cr.state ; structlist = [] ; if ~isempty(operator.struct) struct_names = mttGetFieldNames(operator,'struct') ; number_of_structs = length(struct_names) ; for i = 1:number_of_structs struct_name = struct_names{i} ; variables = getfield(operator,'struct',struct_name) ; if i==1 structlist = variables ; else structlist = [structlist,variables] ; end end end inlist = [] ; outlist = [] ; inlink = [] ; outlink = [] ; input_counter = 0 ; output_counter = 0 ; for i = 1:length(operator.link) if operator.link(i).is_input input_counter = input_counter + 1 ; inlist{input_counter} = operator.link(i).name ; inlink(input_counter) = i ; infree(input_counter) = operator.link(i).is_unconstrained ; else output_counter = output_counter + 1 ; outlist{output_counter} = operator.link(i).name ; outlink(output_counter) = i ; outfree(output_counter) = operator.link(i).is_unconstrained ; end end operator.assign = [] ; ports_with_state_assignment = [] ; for i = 1:length(operator.set) [port_covariable,state] = mttCutText(operator.set{i},'=>') ; mttAssert(~isempty(state),... ['"set" declarations must use "=>" in cr ',cr_name]) ; [port_name,covariable] = mttCutText(port_covariable,'.') ; mttAssert(~isempty(covariable),... ['"set" declarations must reference effort/flow covariables in cr ',cr_name]) ; port = strmatch(port_name,outlist,'exact') ; ports_with_state_assignment = [ports_with_state_assignment,port] ; mttAssert(~isempty(port),... ['Output port "',port_name,'" not recognised for "set" declaration in cr ',cr_name]) ; mttAssert(outfree(port),... ['Constrained port variable used for "set" declaration in cr ',cr_name]) ; actual_port = getfield(cr.interface.port,port_name) ; mttAssert(actual_port.is_effort_state | actual_port.is_flow_state,... ['"set" declarations must only be used for effort_states or flow_states in cr ',cr_name]) ; if isempty(actual_port.domain) if actual_port.is_effort_state covariables = {'effort'} ; elseif actual_port.is_flow_state covariables = {'flow'} ; end else public_domain = mtt_environment.public_domain(actual_port.domain) ; domain_item = getfield(public_domain.item,actual_port.domain_item) ; if actual_port.is_effort_state covariables = domain_item.effort ; elseif actual_port.is_flow_state covariables = domain_item.flow ; end end index = strmatch(covariable,covariables,'exact') ; mttAssert(~isempty(index),... ['Unrecognised covariable "',covariable,'" used for "set" declaration in cr ',cr_name]) ; if isfield(operator.assign,port_name) assignment = getfield(operator,'assign',port_name) ; mttAssert(isempty(assignment.states{index}),... ['Repeated covariable "',covariable,'" used for "set" declaration in cr ',cr_name]) ; else assignment.covar = covariables ; assignment.state{length(covariables)} = [] ; % assignment.domain = actual_port.domain ; % assignment.domain_item = actual_port.domain_item ; end mttAssert(ismember(state,cr.state),... ['Unrecognised state "',state,'" used for "set" declaration in cr ',cr_name]) ; assignment.state{index} = state ; operator = setfield(operator,'assign',port_name,assignment) ; end operator = mttDeleteField(operator,'set') ; port_assignments = mttGetFieldNames(operator,'assign') ; number_of_assignments = length(port_assignments) ; for i = 1:number_of_assignments assignment = getfield(operator,'assign',port_name) ; for j = 1:length(assignment.state) mttAssert(~isempty(assignment.state{j}),... ['Missing covariable "',covariable,'" from "set" declaration in cr ',cr_name]) ; end end for i = 1:length(operator.content) operator.equation(i).chunk = {[]} ; % operator.equation(i).was_generic = 1 ; % operator.equation(i).domain = [] ; % operator.equation(i).domain_item = [] ; % operator.equation(i).is_effort = [] ; % operator.equation(i).covariable = [] ; counter = 0 ; line = operator.content{i} ; if ~isempty(mttClipText(line)) [var,loc] = mttFindEquationVariables(line) ; if loc(1)>1 front = line(1:loc(1)-1) ; counter = counter + 1 ; operator.equation(i).chunk{counter} = front ; end last = length(line) ; for j = 1:length(var) [name,component] = mttCutText(var{j},'.') ; if isempty(component) [name,attribute] = mttCutText(name,'''') ; numpar = strmatch(name,numparlist,'exact') ; sympar = strmatch(name,symparlist,'exact') ; variable = strmatch(name,varlist,'exact') ; struct = strmatch(name,structlist,'exact') ; input = strmatch(name,inputlist,'exact') ; state = strmatch(name,statelist,'exact') ; ok = ~(isempty(numpar)&isempty(sympar)&isempty(variable)&isempty(struct)&isempty(input)&isempty(state)) ; mttAssert(ok,['Variable ',var{j},' not recognised in cr ',cr_name]) ; is_numpar = ~isempty(numpar) ; is_sympar = ~isempty(sympar) ; is_var = ~isempty(variable) ; is_struct = ~isempty(struct) ; is_input = ~isempty(input) ; is_state = ~isempty(state) ; is_derivative = 0 ; if ~isempty(attribute) mttAssert(strcmp(attribute,'dt'),... ['Unrecognised attribute ',attribute,' in cr ',cr_name]) ; mttAssert(is_state,... ['Derivative of non-state variable in cr ',cr_name]) ; is_state = 0 ; is_derivative = 1 ; end counter = counter + 1 ; if is_numpar operator.equation(i).chunk{counter} = {'numpar',numpar} ; end if is_sympar operator.equation(i).chunk{counter} = {'sympar',sympar} ; end if is_var operator.equation(i).chunk{counter} = {'var',variable} ; end if is_struct operator.equation(i).chunk{counter} = {'struct',struct} ; end if is_input operator.equation(i).chunk{counter} = {'input',input} ; end if is_state operator.equation(i).chunk{counter} = {'state',state} ; end if is_derivative operator.equation(i).chunk{counter} = {'derivative',state} ; end else if j==1 port = strmatch(name,outlist,'exact') ; if ~isempty(ports_with_state_assignment) mttAssert(~any(port==ports_with_state_assignment),... ['Use "set" declaration to assign output port ',name,' to state in cr ',cr_name]) ; end mttAssert(~isempty(port),... ['Output port ',name,' not recognised in cr ',cr_name]) ; mttAssert(outfree(port),... ['Constrained port variable used in cr ',cr_name]) ; counter = counter + 1 ; operator.equation(i).chunk{counter} = {'link',outlink(port),component} ; else port = strmatch(name,inlist,'exact') ; mttAssert(~isempty(port),... ['Input port ',name,' not recognised in cr ',cr_name]) ; mttAssert(infree(port),... ['Constrained port variable used in cr ',cr_name]) ; counter = counter + 1 ; operator.equation(i).chunk{counter} = {'link',inlink(port),component} ; end % equation_domain = mttIdentifyUserDomain(mtt_environment,... % operator.equation(i).domain,.... % operator.equation(i).domain_item) ; covariable = component ; port_name = name ; port = getfield(cr.interface.port,port_name) ; if isempty(port.domain) is_effort = strcmp(covariable,'effort') ; is_flow = strcmp(covariable,'flow') ; mttAssert(is_effort|is_flow, ... ['"',covariable,'" is not a generic covariable']) ; % mttAssert(isempty(operator.equation(i).domain),... % ['Generic interface "',port_name,'" referenced in ',equation_domain,' equation']) ; else public_domain = mtt_environment.public_domain(port.domain) ; actual_domain = getfield(public_domain,'item',port.domain_item) ; port_domain = mttIdentifyUserDomain(mtt_environment,port.domain,port.domain_item) ; is_effort = ismember(covariable,actual_domain.effort) ; is_flow = ismember(covariable,actual_domain.flow) ; mttAssert(is_effort|is_flow, ... ['"',covariable,'" is not a covariable defined in domain "',port_domain,'"']) ; % if isempty(equation_domain) % operator.equation(i).was_generic = 0 ; % operator.equation(i).domain = port.domain ; % operator.equation(i).domain_item = port.domain_item ; % operator.equation(i).covariable = covariable ; % else % mttAssert(covariable==operator.equation(i).covariable, ... % ['Equation cannot combine different covariables: [',covariable,',',operator.equation(i).covariable,']') ; % end end % if isempty(operator.equation(i).is_effort) % if is_effort % operator.equation(i).is_effort = 1 ; % else % operator.equation(i).is_effort = 0 ; % end % else % mttAssert(operator.equation(i).is_effort==is_effort,... % ['Effort and flow covariables appear in equation: "',operator.content{i},'"']) ; % end end next = loc(j) + length(var{j}) ; if j<length(var) glue = line(next:loc(j+1)-1) ; counter = counter + 1 ; operator.equation(i).chunk{counter} = glue ; if j==1 mttAssert(~isempty(findstr(glue,':=')),... ['Expect ":=" after first variable in cr ',cr_name]) ; end else if next<=last back = line(next:last) ; counter = counter + 1 ; operator.equation(i).chunk{counter} = back ; end end end end end |
Added mttroot/ntt/bin/trans/m/mttPropagateCausality.m version [3db1dcaa36].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 | function model = mttPropagateCausality(model,branch) is_root_model = (nargin==1) ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; if is_root_model branch = mttDetachText(model.source,'/') ; end here = [branch,':',object_name] ; if isfield(object,'obj') for i = 1:mttGetFieldLength(object,'interface') port_name = object.interface(i).name ; inbond = object.interface(i).in ; outbond = object.interface(i).out ; inmap = object.interface(i).map.in ; outmap = object.interface(i).map.out ; [inbond_effort,inbond_flow,inbond_unicausal] = mttGetBondCausality(model,inbond) ; [outbond_effort,outbond_flow,outbond_unicausal] = mttGetBondCausality(model,outbond) ; [inmap_effort,inmap_flow,inmap_unicausal] = mttGetBondCausality(object,inmap) ; [outmap_effort,outmap_flow,outmap_unicausal] = mttGetBondCausality(object,outmap) ; [model,inbond_ok] = mttUpdateBondCausality(model,inbond,inmap_effort,inmap_flow,inmap_unicausal) ; [model,outbond_ok] = mttUpdateBondCausality(model,outbond,outmap_effort,outmap_flow,outmap_unicausal) ; [object,inmap_ok] = mttUpdateBondCausality(object,inmap,inbond_effort,inbond_flow,inbond_unicausal) ; [object,outmap_ok] = mttUpdateBondCausality(object,outmap,outbond_effort,outbond_flow,outbond_unicausal) ; ok = inbond_ok & outbond_ok & inmap_ok & outmap_ok ; mttAssert(ok,['Causal conflict at port "',port_name,'" in ',here]) ; end if is_root_model branch = object_name ; else branch = [branch,'/',object_name] ; end object = mttPropagateCausality(object,branch) ; model = setfield(model,'obj',object_name,object) ; else number_of_interfaces = mttGetFieldLength(object,'interface') ; switch object.class case {'Se','Sf','De','Df'} for i = 1:number_of_interfaces port_name = object.interface(i).name ; inbond = object.interface(i).in ; outbond = object.interface(i).out ; mttAssert(xor(isempty(inbond),isempty(outbond)),... ['"',object.class,'" objects must have exactly one attached bond in ',here]) ; switch object.class case {'Se','De'}, [model,ok] = mttUpdateBondCausality(model,outbond,[],1,1) ; % Constraint [model] = mttUpdateBondCausality(model,outbond,1,[],1) ; % Preference case {'Sf','Df'}, [model,ok] = mttUpdateBondCausality(model,outbond,0,[],1) ; % Constraint [model] = mttUpdateBondCausality(model,outbond,[],0,1) ; % Preference end mttAssert(ok,['Causal constraint violation at port "',port_name,'" in ',here]) end case '0', mttAssert(number_of_interfaces>1,... ['Less than two interfaces at 0-junction ',here]) ; imposed_effort = [] ; resultant_flow = [] ; for j = 1:number_of_interfaces inbond = object.interface(j).in ; outbond = object.interface(j).out ; if isempty(inbond) bond(j) = outbond ; orientation(j) = 0 ; else bond(j) = inbond ; orientation(j) = 1 ; end [effort,flow,unicausal] = mttGetBondCausality(model,bond(j)) ; if ~isempty(effort) if effort==orientation(j) mttAssert(isempty(imposed_effort),... ['Over-determined effort at 0-junction ',here]) ; imposed_effort = bond(j) ; end end if ~isempty(flow) if flow==orientation(j) mttAssert(isempty(resultant_flow),... ['Over-determined flow at 0-junction ',here]) ; resultant_flow = bond(j) ; end end end for j = 1:number_of_interfaces if ~isempty(imposed_effort) if bond(j)~=imposed_effort model = mttUpdateBondCausality(model,bond(j),~orientation(j),[],[]) ; end end if ~isempty(resultant_flow) if bond(j)~=resultant_flow model = mttUpdateBondCausality(model,bond(j),[],~orientation(j),[]) ; end end end case '1', mttAssert(number_of_interfaces>1,... ['Less than two interfaces at 1-junction ',here]) ; imposed_flow = [] ; resultant_effort = [] ; for j = 1:number_of_interfaces inbond = object.interface(j).in ; outbond = object.interface(j).out ; if isempty(inbond) bond(j) = outbond ; orientation(j) = 0 ; else bond(j) = inbond ; orientation(j) = 1 ; end [effort,flow,unicausal] = mttGetBondCausality(model,bond(j)) ; if ~isempty(effort) if effort~=orientation(j) mttAssert(isempty(resultant_effort),... ['Over-determined effort at 1-junction ',here]) ; resultant_effort = bond(j) ; end end if ~isempty(flow) if flow~=orientation(j) mttAssert(isempty(imposed_flow),... ['Over-determined flow at 1-junction ',here]) ; imposed_flow = bond(j) ; end end end for j = 1:number_of_interfaces if ~isempty(resultant_effort) if bond(j)~=resultant_effort model = mttUpdateBondCausality(model,bond(j),orientation(j),[],[]) ; end end if ~isempty(imposed_flow) if bond(j)~=imposed_flow model = mttUpdateBondCausality(model,bond(j),[],orientation(j),[]) ; end end end end end end |
Added mttroot/ntt/bin/trans/m/mttPropagateDomains.m version [01ad4b747a].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 | function model = mttPropagateDomains(model,branch) is_root_model = (nargin==1) ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; if is_root_model branch = mttDetachText(model.source,'/') ; end here = [branch,':',object_name] ; if ~isempty(object.abg) for j = 1:mttGetFieldLength(object,'interface') port_name = object.interface(j).name ; inbond = object.interface(j).in ; outbond = object.interface(j).out ; inmap = object.interface(j).map.in ; outmap = object.interface(j).map.out ; [inbond_domain,inbond_domain_item] = mttGetBondDomain(model,inbond) ; [outbond_domain,outbond_domain_item] = mttGetBondDomain(model,outbond) ; [inmap_domain,inmap_domain_item] = mttGetBondDomain(object,inmap) ; [outmap_domain,outmap_domain_item] = mttGetBondDomain(object,outmap) ; [model,inbond_ok] = mttUpdateBondDomain(model,inbond,inmap_domain,inmap_domain_item) ; [model,outbond_ok] = mttUpdateBondDomain(model,outbond,outmap_domain,outmap_domain_item) ; [object,inmap_ok] = mttUpdateBondDomain(object,inmap,inbond_domain,inbond_domain_item) ; [object,outmap_ok] = mttUpdateBondDomain(object,outmap,outbond_domain,outbond_domain_item) ; ok = inbond_ok & outbond_ok & inmap_ok & outmap_ok ; mttAssert(ok,['Domain conflict at port "',port_name,'" in ',here]) ; end if is_root_model branch = object_name ; else branch = [branch,'/',object_name] ; end object = mttPropagateDomains(object,branch) ; model = setfield(model,'obj',object_name,object) ; elseif ~isempty(object.cr) interface = object.cr.interface ; port_names = mttGetFieldNames(interface,'port') ; for j = 1:length(port_names) port_name = port_names{j} ; port = getfield(interface,'port',port_name) ; inbond = port.in ; outbond = port.out ; [model,inbond_ok] = mttUpdateBondDomain(model,inbond,port.domain,port.domain_item) ; [model,outbond_ok] = mttUpdateBondDomain(model,outbond,port.domain,port.domain_item) ; ok = inbond_ok & outbond_ok ; mttAssert(ok,['Domain conflict at port "',port_name,'" in ',here]) ; end else number_of_interfaces = mttGetFieldLength(object,'interface') ; switch object.class case {'0','1'}, index = 0 ; finding_domain = 1 ; while finding_domain index = index + 1 ; inbond = object.interface(index).in ; outbond = object.interface(index).out ; if isempty(inbond) bond_number = outbond ; else bond_number = inbond ; end [existing_domain,existing_domain_item] = mttGetBondDomain(model,bond_number) ; found_domain = ~isempty(existing_domain) ; finding_domain = ~found_domain & index<number_of_interfaces ; end if found_domain for j = 1:number_of_interfaces inbond = object.interface(j).in ; outbond = object.interface(j).out ; if isempty(inbond) bond_number = outbond ; else bond_number = inbond ; end model = mttUpdateBondDomain(model,bond_number,existing_domain,existing_domain_item) ; end end end end end |
Added mttroot/ntt/bin/trans/m/mttWriteSystemApps.m version [d508925095].
> > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | function mttWriteSystemApps(model) if ~isfield(model,'app') return ; end filename = [model.source,'_include_apps.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Applications for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; fprintf(fid,'\n\n') ; for i = 1:length(model.app) app_inclusion = ['#include "',model.app{i},'"\n'] ; fprintf(fid,app_inclusion) ; end fclose(fid) ; |
Added mttroot/ntt/bin/trans/m/mttWriteSystemDefinitions.m version [b4ee230811].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 | function mttWriteSystemDefinitions(model) def.structure = define_data_structures(model) ; def.covar = define_bond_covariables(model) ; def.var = define_interface_covariables(model) ; def.sympar = define_symbolic_parameters(model) ; def.numpar = define_numerical_parameters(model) ; def.input = define_input_variables(model) ; def.state = define_state_variables(model) ; def.opvar = define_operator_variables(model) ; write_definitions(def,model) ; function code = define_data_structures(model) mttNotify('...defining data structures') ; mttWriteNewLine ; code = [] ; line = 0 ; tab = char(32*ones(1,3)) ; line = line + 1 ; code{line} = ['typedef struct {'] ; line = line + 1 ; code{line} = [tab,'double state,derivative ;'] ; line = line + 1 ; code{line} = ['} mttState ;'] ; line = line + 1 ; code{line} = '' ; line = line + 1 ; code{line} = ['typedef struct {'] ; line = line + 1 ; code{line} = [tab,'double effort,flow ;'] ; line = line + 1 ; code{line} = ['} mttGenericDomain ;'] ; line = line + 1 ; code{line} = '' ; domain_names = mttGetFieldNames(model.env,'domain') ; for i = 1:length(domain_names) domain_name = domain_names{i} ; domain = getfield(model.env,'domain',domain_name) ; public_domain = model.env.public_domain(domain.dom) ; item_names = mttGetFieldNames(public_domain,'item') ; if isempty(domain.item) first = 1 ; last = length(item_names) ; else first = strmatch(domain.item,item_names,'exact') ; last = first ; end for j = first:last item_name = item_names{j} ; covariables = getfield(public_domain,'item',item_name) ; line = line + 1 ; code{line} = ['typedef struct {'] ; for k = 1:length(covariables.effort) line = line + 1 ; effort_covariable = strrep(covariables.effort{k},'.','__') ; flow_covariable = strrep(covariables.flow{k},'.','__') ; code{line} = [tab,'double ',effort_covariable,',',flow_covariable,' ;'] ; end definition = ['} mttDomain__',domain_name] ; if isempty(domain.item) definition = [definition,'__',item_name] ; end definition = [definition,' ;'] ; line = line + 1 ; code{line} = definition ; if j<last line = line + 1 ; code{line} = '' ; end end line = line + 1 ; code{line} = '' ; end struct_names = mttGetFieldNames(model.env,'struct') ; for i = 1:length(struct_names) struct_name = struct_names{i} ; struct = getfield(model.env,'struct',struct_name) ; public_struct = model.env.public_struct(struct.str) ; item_names = mttGetFieldNames(public_struct,'item') ; index = strmatch(struct.item,item_names,'exact') ; item_name = item_names{index} ; variables = getfield(public_struct,'item',item_name,'var') ; line = line + 1 ; code{line} = ['typedef struct {'] ; for k = 1:length(variables) line = line + 1 ; variable = strrep(variables{k},'.','__') ; code{line} = [tab,'double ',variable,' ;'] ; end definition = ['} ',struct_name,' ;'] ; line = line + 1 ; code{line} = definition ; if i<length(struct_names) line = line + 1 ; code{line} = '' ; end end function code = define_bond_covariables(model,root,branch) is_root_model = nargin==1 ; if is_root_model mttNotify('...defining bond covariables') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; else current_branch = branch ; end width = 0 ; domain_names = mttGetFieldNames(root.env,'domain') ; for j = 1:length(domain_names) domain_name = domain_names{j} ; width = max(width,length(domain_name)) ; end code = [] ; line = 0 ; number_of_bonds = mttGetFieldLength(model,'bond') ; for i = 1:number_of_bonds current_bond = model.bond(i) ; specified_domain = current_bond.domain ; specified_domain_item = current_bond.domain_item ; user_domain_identification = mttIdentifyUserDomain(root.env,specified_domain,specified_domain_item) ; if isempty(user_domain_identification) data_structure = ['mttGenericDomain'] ; else data_structure = ['mttDomain__',user_domain_identification] ; end nominal_width = 14 + width ; actual_width = length(data_structure) ; gap = nominal_width - actual_width ; whitespace = char(32*ones(1,gap+3)) ; line = line + 1 ; code{line} = [data_structure,whitespace,current_branch,'__',num2str(i),' ;'] ; end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; if ~isempty(object.abg) next_branch = [current_branch,'__',object_name] ; additional_code = define_bond_covariables(object,root,next_branch) ; if isempty(code) code = additional_code ; else code = [code,additional_code] ; end end end if line==0 code = [] ; end function code = define_interface_covariables(model) mttNotify('...defining interface covariables') ; mttWriteNewLine ; width = 0 ; domain_names = mttGetFieldNames(model.env,'domain') ; for j = 1:length(domain_names) domain_name = domain_names{j} ; width = max(width,length(domain_name)) ; end code = [] ; line = 0 ; previous_name = model.namelist(1).var ; number_of_variables = mttGetFieldLength(model,'namelist') ; for i = 2:number_of_variables % .... first variable is reserved ! variable_name = model.namelist(i).var ; [variable_name,extension] = mttCutText(variable_name,'.') ; if ~strcmp(variable_name,previous_name) previous_name = variable_name ; specified_domain = model.namelist(i).domain ; specified_domain_item = model.namelist(i).domain_item ; user_domain_identification = mttIdentifyUserDomain(model.env,specified_domain,specified_domain_item) ; if isempty(user_domain_identification) data_structure = ['mttGenericDomain'] ; else data_structure = ['mttDomain__',user_domain_identification] ; end nominal_width = 14 + width ; actual_width = length(data_structure) ; gap = nominal_width - actual_width ; whitespace = char(32*ones(1,gap+3)) ; line = line + 1 ; code{line} = [data_structure,whitespace,variable_name,' ;'] ; end end function code = define_symbolic_parameters(model) mttNotify('...defining symbolic parameters') ; mttWriteNewLine ; model_name = mttDetachText(model.source,'/') ; code = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'sympar') ; for i = 1:number_of_variables variable_name = model.sympar{i} ; default_value = model.sympar_default{i} ; whitespace = char(32*ones(1,3)) ; if isempty(default_value) line = line + 1 ; code{line} = ['double',whitespace,model_name,'___',variable_name,' ;'] ; end end function code = define_numerical_parameters(model,root,branch) is_root_model = nargin==1 ; if is_root_model mttNotify('...defining numerical parameters') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; else current_branch = branch ; end code = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'numpar') ; for i = 1:number_of_variables variable_name = model.numpar{i} ; whitespace = char(32*ones(1,3)) ; line = line + 1 ; code{line} = ['double',whitespace,current_branch,'___',variable_name,' ;'] ; end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; additional_code = [] ; if ~isempty(object.abg) additional_code = define_numerical_parameters(object,root,next_branch) ; elseif ~isempty(object.cr) additional_code = define_numerical_parameters(object.cr,root,next_branch) ; end if isempty(code) code = additional_code ; else line = length(code) ; for j = 1:length(additional_code) if ~ismember(additional_code{j},code) line = line + 1 ; code{line} = additional_code{j} ; end end end end function code = define_input_variables(model,root,branch) is_root_model = nargin==1 ; if is_root_model mttNotify('...defining input variables') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; else current_branch = branch ; end code = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'input') ; for i = 1:number_of_variables variable_name = model.input{i} ; whitespace = char(32*ones(1,3)) ; line = line + 1 ; code{line} = ['double',whitespace,current_branch,'___',variable_name,' ;'] ; end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; additional_code = [] ; if ~isempty(object.abg) additional_code = define_input_variables(object,root,next_branch) ; elseif ~isempty(object.cr) additional_code = define_input_variables(object.cr,root,next_branch) ; end if isempty(code) code = additional_code ; else line = length(code) ; for j = 1:length(additional_code) if ~ismember(additional_code{j},code) line = line + 1 ; code{line} = additional_code{j} ; end end end end function code = define_state_variables(model,root,branch,env) is_root_model = nargin==1 ; if is_root_model mttNotify('...defining state variables') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; env = model.env ; else current_branch = branch ; end whitespace = char(32*ones(1,3)) ; code = [] ; line = 0 ; if isfield(model,'state') assigned_states = [] ; counter = 0 ; port_names = mttGetFieldNames(model.interface,'port') ; for j = 1:length(port_names) port_name = port_names{j} ; port = getfield(model,'interface','port',port_name) ; if ~isempty(port.assign) assignment = port.assign ; if port.was_generic & ~isempty(port.domain) covariables = mttGetCovariables(env,port.domain,port.domain_item) ; if port.is_effort_state covar = covariables.effort ; else covar = covariables.flow ; end block_size = length(covar) ; for k = 1:length(assignment.state) counter = counter + 1 ; assigned_states{counter} = assignment.state{k} ; for var = 1:block_size line = line + 1 ; code{line} = ['mttState',whitespace,current_branch,'___',assignment.state{k},'___',covar{var},' ;'] ; end end end end end number_of_variables = mttGetFieldLength(model,'state') ; for i = 1:number_of_variables variable_name = model.state{i} ; if ~ismember(variable_name,assigned_states) line = line + 1 ; code{line} = ['mttState',whitespace,current_branch,'___',variable_name,' ;'] ; end end end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; additional_code = [] ; if ~isempty(object.abg) additional_code = define_state_variables(object,root,next_branch,env) ; elseif ~isempty(object.cr) additional_code = define_state_variables(object.cr,root,next_branch,env) ; end if isempty(code) code = additional_code ; else line = length(code) ; for j = 1:length(additional_code) if ~ismember(additional_code{j},code) line = line + 1 ; code{line} = additional_code{j} ; end end end end function code = define_operator_variables(model,root,branch) is_root_model = nargin==1 ; if is_root_model mttNotify('...defining operator variables') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; else current_branch = branch ; end code = [] ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; if ~isempty(object.abg) additional_code = define_operator_variables(object,root,next_branch) ; elseif ~isempty(object.cr) line = 0 ; additional_code = [] ; number_of_operators = mttGetFieldLength(object.cr,'operator') ; for j = 1:number_of_operators operator = object.cr.operator(j) ; number_of_vars = mttGetFieldLength(operator,'var') ; for k = 1:number_of_vars variable_name = operator.var{k} ; whitespace = char(32*ones(1,3)) ; line = line + 1 ; prefix = [next_branch,'___',operator.name] ; additional_code{line} = ['double',whitespace,prefix,'___',variable_name,' = 0.0 ;'] ; end struct_names = mttGetFieldNames(operator,'struct') ; number_of_structs = length(struct_names) ; for k = 1:number_of_structs struct_name = struct_names{k} ; variables = getfield(operator,'struct',struct_name) ; for kv = 1:length(variables) variable_name = variables{kv} ; whitespace = char(32*ones(1,3)) ; line = line + 1 ; prefix = [next_branch,'___',operator.name] ; additional_code{line} = [struct_name,whitespace,prefix,'___',variable_name,' ;'] ; end end end end if isempty(code) code = additional_code ; else line = length(code) ; for j = 1:length(additional_code) if ~ismember(additional_code{j},code) line = line + 1 ; code{line} = additional_code{j} ; end end end end function write_definitions(def,model) filename = [model.source,'_include_def.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Definitions for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; write_definitive_list(fid,'data_structures',def.structure) ; write_definitive_list(fid,'bond_covariables',def.covar) ; write_definitive_list(fid,'interface_covariables',def.var) ; write_definitive_list(fid,'symbolic_parameters',def.sympar) ; write_definitive_list(fid,'numerical_parameters',def.numpar) ; write_definitive_list(fid,'input_variables',def.input) ; write_definitive_list(fid,'state_variables',def.state) ; write_definitive_list(fid,'operator_variables',def.opvar) ; fclose(fid) ; function write_definitive_list(fid,var_type,var_list) if ~isempty(var_list) fprintf(fid,'\n\n') ; fprintf(fid,['// ',var_type]) ; fprintf(fid,'\n') ; tab = char(32*ones(1,3)) ; for i = 1:length(var_list) formatted_declaration = [tab,var_list{i},'\n'] ; fprintf(fid,formatted_declaration) ; end end |
Added mttroot/ntt/bin/trans/m/mttWriteSystemEquations.m version [6eecd251a9].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 | function mttWriteSystemEquations(model) [eqn,ini] = format_equations(model) ; write_equations(eqn,ini,model) ; function [eqn,ini] = format_equations(model) mttNotify('...formating ordinary differential equations') ; mttWriteNewLine ; sse = model.equation ; namelist = model.namelist ; tab = char(32*ones(1,3)) ; eqn_counter = 0 ; ini_counter = 0 ; eqn = [] ; ini = [] ; for i = 1:length(sse) content = [] ; indent = 0 ; if isempty(sse(i).operator) Lvar = sse(i).var.LHS ; Rvar = sse(i).var.RHS ; if isnumeric(Lvar) | isnumeric(Rvar) if isnumeric(Lvar) name = sse(i).branch.LHS ; if mod(Lvar,2) bond_number = (Lvar+1)/2 ; else bond_number = Lvar/2 ; end else name = sse(i).branch.RHS ; if mod(Rvar,2) bond_number = (Rvar+1)/2 ; else bond_number = Rvar/2 ; end end [hierarchy,interface] = mttCutText(name,'___') ; level = length(findstr(hierarchy,'__')) ; [root,hierarchy] = mttCutText(hierarchy,'__') ; for j = 1:level [obj{j},hierarchy] = mttCutText(hierarchy,'__') ; end if level==0 local_object = model ; else local_object = getfield(model,'obj',obj{1}) ; for j = 2:level local_object = getfield(local_object,'obj',obj{j}) ; end end [specified_domain,specified_domain_item] = mttGetBondDomain(local_object,bond_number) ; else [name,covar] = mttCutText(namelist(Lvar{1}).var,'.') ; [hierarchy,interface] = mttCutText(name,'___') ; level = length(findstr(hierarchy,'__')) ; [root,hierarchy] = mttCutText(hierarchy,'__') ; for j = 1:level [obj{j},hierarchy] = mttCutText(hierarchy,'__') ; end parent_object = model ; object = getfield(model,'obj',obj{1}) ; for j = 2:level parent_object = object ; object = getfield(object,'obj',obj{j}) ; end index = strmatch(interface,{object.interface.name},'exact') ; interface_definition = object.interface(index) ; if isempty(interface_definition.in) bond_number = interface_definition.out ; else bond_number = interface_definition.in ; end [specified_domain,specified_domain_item] = mttGetBondDomain(parent_object,bond_number) ; end covariables = mttGetCovariables(model.env,specified_domain,specified_domain_item) ; dimension = length(covariables.effort) ; var = sse(i).var.LHS ; branch = sse(i).branch.LHS ; LHS.name = [] ; LHS.is_effort = [] ; switch class(var) case 'double', if mod(var,2) % LHS.name = [branch,'[',num2str((var+1)/2),']'] ; LHS.name = [branch,'__',num2str((var+1)/2)] ; LHS.is_effort = 1 ; else % LHS.name = [branch,'[',num2str(var/2),']'] ; LHS.name = [branch,'__',num2str(var/2)] ; LHS.is_effort = 0 ; end case 'cell', [name,covar] = mttCutText(namelist(var{1}).var,'.') ; LHS.name = name ; if strcmp(covar,'effort') LHS.is_effort = 1 ; else LHS.is_effort = 0 ; end end var = sse(i).var.RHS ; branch = sse(i).branch.RHS ; RHS.name = [] ; RHS.is_effort = [] ; switch class(var) case 'double', if mod(abs(var(1)),2) % RHS.name{1} = [branch,'[',num2str((abs(var(1))+1)/2),']'] ; RHS.name{1} = [branch,'__',num2str((abs(var(1))+1)/2)] ; RHS.is_effort(1) = 1 ; else % RHS.name{1} = [branch,'[',num2str(abs(var(1))/2),']'] ; RHS.name{1} = [branch,'__',num2str(abs(var(1))/2)] ; RHS.is_effort(1) = 0 ; end if var(1)<0 RHS.name{1} = ['-',RHS.name{1}] ; end for j = 2:length(var) if mod(abs(var(j)),2) % RHS.name{j} = [branch,'[',num2str((abs(var(j))+1)/2),']'] ; RHS.name{j} = [branch,'__',num2str((abs(var(j))+1)/2)] ; RHS.is_effort(j) = 1 ; else % RHS.name{j} = [branch,'[',num2str(abs(var(j))/2),']'] ; RHS.name{j} = [branch,'__',num2str(abs(var(j))/2)] ; RHS.is_effort(j) = 0 ; end if var(j)>0 RHS.name{j} = [' + ',RHS.name{j}] ; else RHS.name{j} = [' - ',RHS.name{j}] ; end end case 'cell', [name,covar] = mttCutText(namelist(var{1}).var,'.') ; RHS.name{1} = name ; if strcmp(covar,'effort') | strcmp(covar,'effort_state') RHS.is_effort = 1 ; else RHS.is_effort = 0 ; end end for k = 1:dimension if LHS.is_effort covar = covariables.effort{k} ; else covar = covariables.flow{k} ; end content = [LHS.name,'.',strrep(covar,'.','__')] ; indent = char(32*ones(1,length(content)+3)) ; for j = 1:length(RHS.name) if RHS.is_effort(j) covar = covariables.effort{k} ; else covar = covariables.flow{k} ; end if j==1 if strcmp(RHS.name{1},'0') content = [content,' = ',RHS.name{1}] ; else content = [content,' = ',RHS.name{1},'.',strrep(covar,'.','__')] ; end else content = [content,'\n',indent,RHS.name{j},'.',strrep(covar,'.','__')] ; end end content = [content,' ;'] ; if ~isempty(content) eqn_counter = eqn_counter + 1 ; eqn{eqn_counter} = content ; end end else op = [sse(i).operator] ; [cr,operator] = mttCutText(op,'___') ; if ~strcmp(eqn{eqn_counter},'') eqn_counter = eqn_counter + 1 ; eqn{eqn_counter} = [''] ; end eqn_counter = eqn_counter + 1 ; eqn{eqn_counter} = ['// ',op] ; [root,hierarchy] = mttCutText(cr,'__') ; level = length(findstr(cr,'__')) ; for j = 1:level [obj{j},hierarchy] = mttCutText(hierarchy,'__') ; end object = getfield(model,'obj',obj{1}) ; for j = 2:level object = getfield(object,'obj',obj{j}) ; end index = strmatch(operator,{object.cr.operator.name},'exact') ; cr_definition = object.cr ; operator_definition = cr_definition.operator(index) ; structlist = [] ; if ~isempty(operator_definition.struct) struct_names = mttGetFieldNames(operator_definition,'struct') ; number_of_structs = length(struct_names) ; for i = 1:number_of_structs struct_name = struct_names{i} ; variables = getfield(operator_definition,'struct',struct_name) ; if i==1 structlist = variables ; else structlist = [structlist,variables] ; end end end reassigned_state_list = [] ; counter = 0 ; port_names = mttGetFieldNames(cr_definition.interface,'port') ; for j = 1:length(port_names) port_name = port_names{j} ; port = getfield(cr_definition,'interface','port',port_name) ; if ~isempty(port.assign) assignment = port.assign ; if port.was_generic & ~isempty(port.domain) covar = mttGetCovariables(model.env,port.domain,port.domain_item) ; if port.is_effort_state covar = covariables.effort ; else covar = covariables.flow ; end for k = 1:length(assignment.state) counter = counter + 1 ; reassigned_state_list.name{counter} = assignment.state{k} ; reassigned_state_list.covar{counter} = covar ; end block_size = length(covar) ; for var = 1:block_size segment = [] ; for k = 1:length(assignment.state) segment{1} = [cr,'___',port_name,'.',strrep(covar{var},'.','__')] ; segment{2} = [' = '] ; segment{3} = [cr,'___',assignment.state{k},'___',strrep(covar{var},'.','__'),'.state ;'] ; ini_counter = ini_counter + 1 ; ini{ini_counter} = [segment{1},segment{2},segment{3}] ; end end else for k = 1:length(assignment.state) segment{1} = [cr,'___',port_name,'.',strrep(assignment.covar{k},'.','__')] ; segment{2} = [' = '] ; segment{3} = [cr,'___',assignment.state{k},'.state ;'] ; ini_counter = ini_counter + 1 ; ini{ini_counter} = [segment{1},segment{2},segment{3}] ; end end end end equations = operator_definition.equation ; for j = 1:length(equations) equation = equations(j) ; number_of_chunks = mttGetFieldLength(equation,'chunk') ; equation.domain = [] ; equation.domain_item = [] ; for k = 1:number_of_chunks chunk = equation.chunk{k} ; switch class(chunk) case 'cell' type = chunk{1} ; index = chunk{2} ; switch type case 'link' port_name = operator_definition.link(index).name ; port = getfield(cr_definition,'interface','port',port_name) ; if port.was_generic & ~isempty(port.domain) if isempty(equation.domain) equation.domain = port.domain ; equation.domain_item = port.domain_item ; else same_domain = equation.domain==port.domain ; same_domain_item = strcmp(equation.domain_item,port.domain_item) ; mttAssert(same_domain&same_domain_item,... ['Attempt to overwrite implicit variables with conflicting domains in "',... operator_definition.content{j},'"']) ; end end end end end covariables = mttGetCovariables(model.env,equation.domain,equation.domain_item) ; % if equation.is_effort % covar = covariables.effort ; % else % covar = covariables.flow ; % end block_size = length(covariables.effort) ; for line = 1:block_size segment = [] ; content = [] ; for k = 1:number_of_chunks chunk = equation.chunk{k} ; switch class(chunk) case 'cell' type = chunk{1} ; index = chunk{2} ; switch type case 'link' port_variable = [cr,'___',operator_definition.link(index).name] ; if strcmp(chunk{3},'generic___effort') segment{k} = [port_variable,'.',strrep(covariables.effort{line},'.','__')] ; elseif strcmp(chunk{3},'generic___flow') segment{k} = [port_variable,'.',strrep(covariables.flow{line},'.','__')] ; else segment{k} = [port_variable,'.',strrep(chunk{3},'.','__')] ; end % if length(chunk)>2 % segment{k} = [port_variable,'.',strrep(chunk{3},'.','__')] ; % else % segment{k} = [port_variable,'.',strrep(covar{line},'.','__')] ; % end case 'numpar' segment{k} = [cr,'___',cr_definition.numpar{index}] ; case 'sympar' parameter = [cr_definition.parameter{index}] ; if isnumeric(parameter) segment{k} = num2str(parameter) ; else segment{k} = [cr_definition.parameter{index}] ; end case 'var' segment{k} = [op,'___',operator_definition.var{index}] ; case 'struct' segment{k} = [op,'___',structlist{index}] ; case 'input' segment{k} = [cr,'___',cr_definition.input{index}] ; case 'state' state = cr_definition.state{index} ; if isempty(reassigned_state_list) state_reassignment = [] ; else state_reassignment = strmatch(state,reassigned_state_list.name,'exact') ; end if isempty(state_reassignment) segment{k} = [cr,'___',state,'.state'] ; else state_covar = reassigned_state_list.covar{line} ; segment{k} = [cr,'___',state,'___',state_covar{1},'.state'] ; end % segment{k} = [cr,'___',cr_definition.state{index},'.state'] ; case 'derivative' state = cr_definition.state{index} ; if isempty(reassigned_state_list) state_reassignment = [] ; else state_reassignment = strmatch(state,reassigned_state_list.name,'exact') ; end if isempty(state_reassignment) segment{k} = [cr,'___',state,'.derivative'] ; else state_covar = reassigned_state_list.covar{line} ; segment{k} = [cr,'___',state,'___',state_covar{1},'.derivative'] ; end % segment{k} = [cr,'___',cr_definition.state{index},'.derivative'] ; end otherwise chunk = strrep(chunk,':=','=') ; segment{k} = chunk ; end end content = [tab,segment{1}] ; for k = 2:length(segment) content = [content,segment{k}] ; end content = [content,' ;'] ; eqn_counter = eqn_counter + 1 ; eqn{eqn_counter} = content ; end end eqn_counter = eqn_counter + 1 ; eqn{eqn_counter} = ['// End of ',op] ; eqn_counter = eqn_counter + 1 ; eqn{eqn_counter} = [''] ; end end eqn = eqn' ; ini = ini' ; function write_equations(eqn,ini,model) filename = [model.source,'_include_ode.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; fprintf(fid,'\n\n') ; tab = char(32*ones(1,3)) ; for i = 1:length(ini) formatted_equation = [tab,ini{i},'\n'] ; fprintf(fid,formatted_equation) ; end fprintf(fid,'\n') ; for i = 1:length(eqn) formatted_equation = [tab,eqn{i},'\n'] ; fprintf(fid,formatted_equation) ; end fclose(fid) ; |
Added mttroot/ntt/bin/trans/m/mttWriteSystemInitialisation.m version [e48f28b850].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 | function mttWriteSystemInitialisation(model) assignment.numpar = assign_numerical_parameters(model) ; assignment.sympar = assign_symbolic_parameters(model) ; assignment.input = assign_input_variables(model) ; assignment.invar = assign_input_covariables(model) ; assignment.state = assign_state_variables(model) ; write_set_numpar(assignment,model) ; write_set_input(assignment,model) ; write_set_state(assignment,model) ; function code = assign_symbolic_parameters(model) mttNotify('...assigning symbolic parameters') ; mttWriteNewLine ; model_name = mttDetachText(model.source,'/') ; code = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'sympar') ; for i = 1:number_of_variables variable_name = model.sympar{i} ; default = model.sympar_default{i} ; if isempty(default) line = line + 1 ; code{line} = [model_name,'___',variable_name,' = 1.0 ;'] ; else line = line + 1 ; code{line} = [model_name,'___',variable_name,' = ',default,' ;'] ; end end function code = assign_numerical_parameters(model,root,branch) is_root_model = nargin==1 ; if is_root_model mttNotify('...assigning numerical parameters') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; else current_branch = branch ; end code = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'numpar') ; for i = 1:number_of_variables variable_name = model.numpar{i} ; default = model.numpar_default{i} ; line = line + 1 ; if isempty(default) code{line} = [current_branch,'___',variable_name,' = 1.0 ;'] ; else code{line} = [current_branch,'___',variable_name,' = ',default,' ;'] ; end end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; additional_code = [] ; if ~isempty(object.abg) additional_code = assign_numerical_parameters(object,root,next_branch) ; elseif ~isempty(object.cr) additional_code = assign_numerical_parameters(object.cr,root,next_branch) ; end if isempty(code) code = additional_code ; else line = length(code) ; for j = 1:length(additional_code) if ~ismember(additional_code{j},code) line = line + 1 ; code{line} = additional_code{j} ; end end end end function code = assign_input_variables(model,root,branch) is_root_model = nargin==1 ; if is_root_model mttNotify('...assigning input variables') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; else current_branch = branch ; end code = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'input') ; for i = 1:number_of_variables variable_name = model.input{i} ; default = model.input_default{i} ; line = line + 1 ; if isempty(default) code{line} = [current_branch,'___',variable_name,' = 0.0 ;'] ; else code{line} = [current_branch,'___',variable_name,' = ',default,' ;'] ; end end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; additional_code = [] ; if ~isempty(object.abg) additional_code = assign_input_variables(object,root,next_branch) ; elseif ~isempty(object.cr) additional_code = assign_input_variables(object.cr,root,next_branch) ; end if isempty(code) code = additional_code ; else line = length(code) ; for j = 1:length(additional_code) if ~ismember(additional_code{j},code) line = line + 1 ; code{line} = additional_code{j} ; end end end end function code = assign_input_covariables(model,root,branch,env) is_root_model = nargin==1 ; if is_root_model mttNotify('...assigning input covariables') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; env = model.env ; else current_branch = branch ; end code = [] ; line = 0 ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; switch object.class case {'SS','Se','Sf','De','Df'} inbond_number = object.interface.in ; outbond_number = object.interface.out ; inbond = model.bond(inbond_number) ; outbond = model.bond(outbond_number) ; if ~isempty(inbond) covariables = mttGetCovariables(env,inbond.domain,inbond.domain_item) ; covar = [] ; if ~inbond.effort if ~strcmp(object.class,'Df') covar = covariables.effort ; end elseif inbond.flow if ~strcmp(object.class,'De') covar = covariables.flow ; end end for j = 1:length(covar) line = line + 1 ; covariable = strrep(covar{j},'.','__') ; code{line} = [current_branch,'__',object_name,'.',covariable,' = 0.0 ;'] ; end end if ~isempty(outbond) covariables = mttGetCovariables(env,outbond.domain,outbond.domain_item) ; if outbond.effort covar = covariables.effort ; elseif ~outbond.flow covar = covariables.flow ; end for j = 1:length(covar) line = line + 1 ; covariable = strrep(covar{j},'.','__') ; code{line} = [current_branch,'__',object_name,'.',covariable,' = 0.0 ;'] ; end end end additional_code = [] ; if ~isempty(object.abg) additional_code = assign_input_covariables(object,root,next_branch,env) ; end if isempty(code) code = additional_code ; else line = length(code) ; for j = 1:length(additional_code) if ~ismember(additional_code{j},code) line = line + 1 ; code{line} = additional_code{j} ; end end end end function code = assign_state_variables(model,root,branch,env) is_root_model = nargin==1 ; if is_root_model mttNotify('...assigning state variables') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; env = model.env ; else current_branch = branch ; end code = [] ; line = 0 ; if isfield(model,'state') assigned_states = [] ; counter = 0 ; port_names = mttGetFieldNames(model.interface,'port') ; for j = 1:length(port_names) port_name = port_names{j} ; port = getfield(model,'interface','port',port_name) ; if ~isempty(port.assign) assignment = port.assign ; if port.was_generic & ~isempty(port.domain) covariables = mttGetCovariables(env,port.domain,port.domain_item) ; if port.is_effort_state covar = covariables.effort ; default = covariables.effort_default ; else covar = covariables.flow ; default = covariables.flow_default ; end block_size = length(covar) ; for k = 1:length(assignment.state) counter = counter + 1 ; assigned_states{counter} = assignment.state{k} ; for var = 1:block_size line = line + 1 ; if isempty(default{var}) code{line} = [current_branch,'___',assignment.state{k},'___',covar{var},'.state = 0.0 ;'] ; else code{line} = [current_branch,'___',assignment.state{k},'___',covar{var},'.state = ',default{var},' ;'] ; end end end end end end number_of_variables = mttGetFieldLength(model,'state') ; for i = 1:number_of_variables variable_name = model.state{i} ; default = model.state_default{i} ; if ~ismember(variable_name,assigned_states) line = line + 1 ; if isempty(default) code{line} = [current_branch,'___',variable_name,'.state = 0.0 ;'] ; else code{line} = [current_branch,'___',variable_name,'.state = ',default,' ;'] ; end end end end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; additional_code = [] ; if ~isempty(object.abg) additional_code = assign_state_variables(object,root,next_branch,env) ; elseif ~isempty(object.cr) additional_code = assign_state_variables(object.cr,root,next_branch,env) ; end if isempty(code) code = additional_code ; else line = length(code) ; for j = 1:length(additional_code) if ~ismember(additional_code{j},code) line = line + 1 ; code{line} = additional_code{j} ; end end end end function write_set_numpar(assignment,model) filename = [model.source,'_include_set_numpar.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Numerical Parameters for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; model_name = mttDetachText(model.source,'/') ; write_assigned_list(fid,[],assignment.numpar,model_name) ; fclose(fid) ; function write_set_input(assignment,model) filename = [model.source,'_include_set_input.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Default Inputs for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; model_name = mttDetachText(model.source,'/') ; write_assigned_list(fid,'symbolic_parameters',assignment.sympar,model_name) ; write_assigned_list(fid,'input_variables',assignment.input,model_name) ; write_assigned_list(fid,'input_covariables',assignment.invar,model_name) ; fclose(fid) ; function write_set_state(assignment,model) filename = [model.source,'_include_set_state.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Initial states for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; model_name = mttDetachText(model.source,'/') ; write_assigned_list(fid,[],assignment.state,model_name) ; fclose(fid) ; function write_assigned_list(fid,var_type,var_list,model_name) if ~isempty(var_list) if ~isempty(var_type) fprintf(fid,'\n\n') ; fprintf(fid,['// ',var_type]) ; end fprintf(fid,'\n') ; var_list = sort(var_list) ; width = 0 ; for i = 1:length(var_list) [left,right] = mttCutText(var_list{i},'=') ; width = max(width,length(left)) ; end tab = char(32*ones(1,3)) ; for i = 1:length(var_list) [left,right] = mttCutText(var_list{i},'=') ; nominal_width = width ; actual_width = length(left) ; gap = nominal_width - actual_width ; whitespace = char(32*ones(1,gap)) ; formatted_assignment = [tab,left,whitespace,' = ',right,'\n'] ; fprintf(fid,formatted_assignment) ; end end |
Added mttroot/ntt/bin/trans/m/mttWriteSystemMapping.m version [10f14b69b1].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 | function mttWriteSystemMapping(model) sympar = map_system_sympars(model) ; input = map_system_inputs(model) ; invar = map_system_invars(model) ; outvar = map_system_outvars(model) ; state = map_system_states(model) ; derivative = differentiate(state) ; mapping.input = invar ; if ~isempty(input) mapping.input = [mapping.input,input] ; end if ~isempty(sympar) mapping.input = [mapping.input,sympar] ; end mapping.output = outvar ; mapping.state = state ; mapping.derivative = derivative ; write_get_input(mapping,model) ; write_get_state(mapping,model) ; write_put_input(mapping,model) ; write_put_state(mapping,model) ; write_put_output(mapping,model) ; write_put_derivative(mapping,model) ; function map = map_system_sympars(model) mttNotify('...mapping system inputs (symbolic parameters)') ; mttWriteNewLine ; model_name = mttDetachText(model.source,'/') ; map = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'sympar') ; for i = 1:number_of_variables variable_name = model.sympar{i} ; default_value = model.sympar_default{i} ; if isempty(default_value) line = line + 1 ; map{line} = [model_name,'___',variable_name] ; end end function map = map_system_inputs(model,root,branch) is_root_model = nargin==1 ; if is_root_model mttNotify('...mapping system inputs (input variables)') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; else current_branch = branch ; end map = [] ; line = 0 ; number_of_variables = mttGetFieldLength(model,'input') ; for i = 1:number_of_variables variable_name = model.input{i} ; line = line + 1 ; map{line} = [current_branch,'___',variable_name] ; end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; additional_map = [] ; if ~isempty(object.abg) additional_map = map_system_inputs(object,root,next_branch) ; elseif ~isempty(object.cr) additional_map = map_system_inputs(object.cr,root,next_branch) ; end if isempty(map) map = additional_map ; else line = length(map) ; for j = 1:length(additional_map) if ~ismember(additional_map{j},map) line = line + 1 ; map{line} = additional_map{j} ; end end end end function map = map_system_invars(model,root,branch,env) is_root_model = nargin==1 ; if is_root_model mttNotify('...mapping system inputs (input covariables)') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; env = model.env ; else current_branch = branch ; end map = [] ; line = 0 ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; switch object.class case {'SS','Se','Sf','De','Df'} inbond_number = object.interface.in ; outbond_number = object.interface.out ; inbond = model.bond(inbond_number) ; outbond = model.bond(outbond_number) ; if ~isempty(inbond) covariables = mttGetCovariables(env,inbond.domain,inbond.domain_item) ; covar = [] ; if ~inbond.effort if ~strcmp(object.class,'Df') covar = covariables.effort ; end elseif inbond.flow if ~strcmp(object.class,'De') covar = covariables.flow ; end end for j = 1:length(covar) line = line + 1 ; map{line} = [current_branch,'__',object_name,'.',strrep(covar{j},'.','__')] ; end end if ~isempty(outbond) covariables = mttGetCovariables(env,outbond.domain,outbond.domain_item) ; covar = [] ; if outbond.effort covar = covariables.effort ; elseif ~outbond.flow covar = covariables.flow ; end for j = 1:length(covar) line = line + 1 ; map{line} = [current_branch,'__',object_name,'.',strrep(covar{j},'.','__')] ; end end end additional_map = [] ; if ~isempty(object.abg) additional_map = map_system_invars(object,root,next_branch,env) ; end if isempty(map) map = additional_map ; else line = length(map) ; for j = 1:length(additional_map) if ~ismember(additional_map{j},map) line = line + 1 ; map{line} = additional_map{j} ; end end end end function map = map_system_outvars(model,root,branch,env) is_root_model = nargin==1 ; if is_root_model mttNotify('...mapping system outputs (output covariables)') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; env = model.env ; else current_branch = branch ; end map = [] ; line = 0 ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; switch object.class case {'SS','Se','Sf','De','Df'} inbond_number = object.interface.in ; outbond_number = object.interface.out ; inbond = model.bond(inbond_number) ; outbond = model.bond(outbond_number) ; if ~isempty(inbond) covariables = mttGetCovariables(env,inbond.domain,inbond.domain_item) ; covar = [] ; if inbond.effort covar = covariables.effort ; elseif ~inbond.flow covar = covariables.flow ; end for j = 1:length(covar) line = line + 1 ; map{line} = [current_branch,'__',object_name,'.',strrep(covar{j},'.','__')] ; end end if ~isempty(outbond) covariables = mttGetCovariables(env,outbond.domain,outbond.domain_item) ; covar = [] ; if ~outbond.effort if ~strcmp(object.class,'Sf') covar = covariables.effort ; end elseif outbond.flow if ~strcmp(object.class,'Se') covar = covariables.flow ; end end for j = 1:length(covar) line = line + 1 ; map{line} = [current_branch,'__',object_name,'.',strrep(covar{j},'.','__')] ; end end end additional_map = [] ; if ~isempty(object.abg) additional_map = map_system_outvars(object,root,next_branch,env) ; end if isempty(map) map = additional_map ; else line = length(map) ; for j = 1:length(additional_map) if ~ismember(additional_map{j},map) line = line + 1 ; map{line} = additional_map{j} ; end end end end function map = map_system_states(model,root,branch,env) is_root_model = nargin==1 ; if is_root_model mttNotify('...mapping system states') ; mttWriteNewLine ; root = model ; current_branch = mttDetachText(model.source,'/') ; env = model.env ; else current_branch = branch ; end map = [] ; line = 0 ; if isfield(model,'state') assigned_states = [] ; counter = 0 ; port_names = mttGetFieldNames(model.interface,'port') ; for j = 1:length(port_names) port_name = port_names{j} ; port = getfield(model,'interface','port',port_name) ; if ~isempty(port.assign) assignment = port.assign ; if port.was_generic & ~isempty(port.domain) covariables = mttGetCovariables(env,port.domain,port.domain_item) ; if port.is_effort_state covar = covariables.effort ; else covar = covariables.flow ; end block_size = length(covar) ; for k = 1:length(assignment.state) counter = counter + 1 ; assigned_states{counter} = assignment.state{k} ; for var = 1:block_size line = line + 1 ; map{line} = [current_branch,'___',assignment.state{k},'___',covar{var},'.state'] ; end end end end end number_of_variables = mttGetFieldLength(model,'state') ; for i = 1:number_of_variables variable_name = model.state{i} ; if ~ismember(variable_name,assigned_states) line = line + 1 ; map{line} = [current_branch,'___',variable_name,'.state'] ; end end end objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; next_branch = [current_branch,'__',object_name] ; additional_map = [] ; if ~isempty(object.abg) additional_map = map_system_states(object,root,next_branch,env) ; elseif ~isempty(object.cr) additional_map = map_system_states(object.cr,root,next_branch,env) ; end if isempty(map) map = additional_map ; else line = length(map) ; for j = 1:length(additional_map) if ~ismember(additional_map{j},map) line = line + 1 ; map{line} = additional_map{j} ; end end end end function derivative = differentiate(state) mttNotify('...mapping system derivatives') ; mttWriteNewLine ; for i = 1:length(state) derivative{i} = strrep(state{i},'.state','.derivative') ; end function write_get_input(mapping,model) filename = [model.source,'_include_get_input.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Input get-mapping for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; model_name = mttDetachText(model.source,'/') ; write_mapping(fid,'_mttInput',mapping.input,model_name,1) ; fclose(fid) ; function write_put_input(mapping,model) filename = [model.source,'_include_put_input.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Input put-mapping for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; model_name = mttDetachText(model.source,'/') ; write_mapping(fid,'_mttInput',mapping.input,model_name,0) ; fclose(fid) ; function write_get_state(mapping,model) filename = [model.source,'_include_get_state.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// State get-mapping for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; model_name = mttDetachText(model.source,'/') ; write_mapping(fid,'_mttState',mapping.state,model_name,1) ; fclose(fid) ; function write_put_state(mapping,model) filename = [model.source,'_include_put_state.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// State put-mapping for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; model_name = mttDetachText(model.source,'/') ; write_mapping(fid,'_mttState',mapping.state,model_name,0) ; fclose(fid) ; function write_put_output(mapping,model) filename = [model.source,'_include_put_output.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Output put-mapping for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; model_name = mttDetachText(model.source,'/') ; write_mapping(fid,'_mttOutput',mapping.output,model_name,0) ; fclose(fid) ; function write_put_derivative(mapping,model) filename = [model.source,'_include_put_derivative.h'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; fprintf(fid,['// Derivative put-mapping for Ordinary Differential Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; model_name = mttDetachText(model.source,'/') ; write_mapping(fid,'_mttDerivative',mapping.derivative,model_name,0) ; fclose(fid) ; function write_mapping(fid,array_name,var_list,model_name,is_inward_mapping) if ~isempty(var_list) var_list = sort(var_list) ; width = 0 ; for i = 1:length(var_list) width = max(width,length(var_list{i})) ; end tab = char(32*ones(1,3)) ; fprintf(fid,'\n') ; for i = 1:length(var_list) variable = var_list{i} ; if is_inward_mapping nominal_width = width ; actual_width = length(variable) ; gap = nominal_width - actual_width ; whitespace = char(32*ones(1,gap)) ; formatted_mapping = [tab,variable,whitespace,' = ',array_name,'[',num2str(i-1),'] ;\n'] ; else formatted_mapping = [tab,array_name,'[',num2str(i-1),'] = ',variable,' ;\n'] ; end fprintf(fid,formatted_mapping) ; end end |
Added mttroot/ntt/bin/trans/m/mttWriteSystemSfun.m version [ac6231b47a].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 | function mttWriteSystemSfun(model) model_name = mttDetachText(model.source,'/') ; working_directory = pwd ; working_directory = strrep(working_directory,'\','/') ; filename = [working_directory,'/',model_name,'_sfun.cpp'] ; fid = fopen(filename,'w') ; mttNotify(['...creating ',filename]) ; mttWriteNewLine ; model_name = mttDetachText(model.source,'/') ; fprintf(fid,['// Simulation Code for "',model_name,'"\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename ,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; fprintf(fid,'\n') ; write_sfun(fid,model) ; fclose(fid) ; function write_sfun(fid,model) model_name = mttDetachText(model.source,'/') ; counter = mttCountSystemMapping(model) ; fprintf(fid,['#define S_FUNCTION_NAME ',model_name,'_sfun' ,'\n']) ; fprintf(fid,['#define S_FUNCTION_LEVEL 2' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_def.h"' ,'\n']) ; if isfield(model,'app') if ~isempty(model.app) fprintf(fid,['#include "',model_name,'_include_apps.h"' ,'\n']) ; end end fprintf(fid,['#include "simstruc.h"' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static double *_mttInput ;' ,'\n']) ; fprintf(fid,['static double *_mttState ;' ,'\n']) ; fprintf(fid,['static double *_mttDerivative ;' ,'\n']) ; fprintf(fid,['static double *_mttOutput ;' ,'\n']) ; fprintf(fid,['static double _mttTime ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static unsigned int _mttIndex ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['const int _mttNumInputs = ',num2str(counter.input),' ;' ,'\n']) ; fprintf(fid,['const int _mttNumOutputs = ',num2str(counter.output),' ;' ,'\n']) ; fprintf(fid,['const int _mttNumStates = ',num2str(counter.state),' ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['// system equations' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void ',model_name,'_set_numpar (void) {' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_set_numpar.h"' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void ',model_name,'_set_input (void) {' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_set_input.h"' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void ',model_name,'_set_state (void) {' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_set_state.h"' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void ',model_name,'_get_input (void) {' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_get_input.h"' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void ',model_name,'_get_state (void) {' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_get_state.h"' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void ',model_name,'_put_state (void) {' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_put_state.h"' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void ',model_name,'_put_derivative (void) {' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_put_derivative.h"' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void ',model_name,'_put_output (void) {' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_put_output.h"' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void ',model_name,'_ode (void) {' ,'\n']) ; fprintf(fid,['#include "',model_name,'_include_ode.h"' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['// utility procedures' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static double *array_of_double (size_t n)' ,'\n']) ; fprintf(fid,['{' ,'\n']) ; fprintf(fid,[' void *p = calloc (n, sizeof (double)) ;' ,'\n']) ; fprintf(fid,[' if (! p) fprintf (stderr, "*** ERROR: failed to allocate memory") ;','\n']) ; fprintf(fid,[' return (double *) p ;' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void initialise_arrays (void)' ,'\n']) ; fprintf(fid,['{' ,'\n']) ; fprintf(fid,[' _mttInput = array_of_double(_mttNumInputs) ;' ,'\n']) ; fprintf(fid,[' _mttOutput = array_of_double(_mttNumOutputs) ;' ,'\n']) ; fprintf(fid,[' _mttState = array_of_double(_mttNumStates) ;' ,'\n']) ; fprintf(fid,[' _mttDerivative = array_of_double(_mttNumStates) ;' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void check_finite(SimStruct *S, double *array, unsigned int index)','\n']) ; fprintf(fid,['{' ,'\n']) ; fprintf(fid,[' const char *array_name ;' ,'\n']) ; fprintf(fid,[' char warning[128] ;' ,'\n']) ; fprintf(fid,[' if ((array[index] <= 0.0) || (array[index] >= 0.0)) {' ,'\n']) ; fprintf(fid,[' ; // ...no problem' ,'\n']) ; fprintf(fid,[' } else {' ,'\n']) ; fprintf(fid,[' if (array == _mttInput) {' ,'\n']) ; fprintf(fid,[' array_name = "_mttInput" ;' ,'\n']) ; fprintf(fid,[' } else if (array == _mttState) {' ,'\n']) ; fprintf(fid,[' array_name = "_mttState" ;' ,'\n']) ; fprintf(fid,[' } else if (array == _mttOutput) {' ,'\n']) ; fprintf(fid,[' array_name = "_mttOutput" ;' ,'\n']) ; fprintf(fid,[' } else if (array == _mttDerivative) {' ,'\n']) ; fprintf(fid,[' array_name = "_mttDerivative" ;' ,'\n']) ; fprintf(fid,[' } else {' ,'\n']) ; fprintf(fid,[' array_name = "unknown_array" ;' ,'\n']) ; fprintf(fid,[' }' ,'\n']) ; fprintf(fid,[' sprintf(warning,"(time %%f) Non-finite array element: %%s[%%d]",_mttTime,array_name,index) ;','\n']) ; fprintf(fid,[' ssWarning(S,warning) ;' ,'\n']) ; fprintf(fid,[' }' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['// S-function methods' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void mdlInitializeSizes(SimStruct *S)' ,'\n']) ; fprintf(fid,['{' ,'\n']) ; fprintf(fid,[' ssSetNumSFcnParams(S,0) ;' ,'\n']) ; fprintf(fid,[' if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) return ;','\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,[' ssSetNumContStates(S,_mttNumStates) ;' ,'\n']) ; fprintf(fid,[' ssSetNumDiscStates(S,0) ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,[' if (!ssSetNumInputPorts(S,1)) return ;' ,'\n']) ; fprintf(fid,[' ssSetInputPortWidth(S,0,_mttNumInputs) ;' ,'\n']) ; fprintf(fid,[' ssSetInputPortDirectFeedThrough(S,0,1) ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,[' if (!ssSetNumOutputPorts(S,1)) return ;' ,'\n']) ; fprintf(fid,[' ssSetOutputPortWidth(S,0,_mttNumOutputs) ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,[' ssSetNumSampleTimes(S,1) ;' ,'\n']) ; fprintf(fid,[' ssSetNumRWork(S,0) ;' ,'\n']) ; fprintf(fid,[' ssSetNumIWork(S,0) ;' ,'\n']) ; fprintf(fid,[' ssSetNumPWork(S,0) ;' ,'\n']) ; fprintf(fid,[' ssSetNumModes(S,0) ;' ,'\n']) ; fprintf(fid,[' ssSetNumNonsampledZCs(S,0) ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,[' ssSetOptions(S,SS_OPTION_EXCEPTION_FREE_CODE) ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,[' initialise_arrays() ;' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void mdlInitializeSampleTimes(SimStruct *S)' ,'\n']) ; fprintf(fid,['{' ,'\n']) ; fprintf(fid,[' ssSetSampleTime(S,0,CONTINUOUS_SAMPLE_TIME) ;' ,'\n']) ; fprintf(fid,[' ssSetOffsetTime(S,0,0.0) ;' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['#define MDL_INITIALIZE_CONDITIONS' ,'\n']) ; fprintf(fid,['static void mdlInitializeConditions(SimStruct *S)' ,'\n']) ; fprintf(fid,['{' ,'\n']) ; fprintf(fid,[' ',model_name,'_set_numpar() ;' ,'\n']) ; fprintf(fid,[' ',model_name,'_set_state() ;' ,'\n']) ; fprintf(fid,[' ',model_name,'_put_state() ;' ,'\n']) ; fprintf(fid,[' for (_mttIndex=0; _mttIndex<_mttNumStates; _mttIndex++) ssGetContStates(S)[_mttIndex] = _mttState[_mttIndex] ;','\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void mdlOutputs(SimStruct *S,int_T tid)' ,'\n']) ; fprintf(fid,['{' ,'\n']) ; fprintf(fid,[' UNUSED_ARG(tid) ;' ,'\n']) ; fprintf(fid,[' for (_mttIndex=0; _mttIndex<_mttNumStates; _mttIndex++) {' ,'\n']) ; fprintf(fid,[' _mttState[_mttIndex] = ssGetContStates(S)[_mttIndex] ;' ,'\n']) ; fprintf(fid,[' check_finite(S,_mttState,_mttIndex) ;' ,'\n']) ; fprintf(fid,[' }' ,'\n']) ; fprintf(fid,[' for (_mttIndex=0; _mttIndex<_mttNumInputs; _mttIndex++) {' ,'\n']) ; fprintf(fid,[' _mttInput[_mttIndex] = *ssGetInputPortRealSignalPtrs(S,0)[_mttIndex] ;','\n']) ; fprintf(fid,[' check_finite(S,_mttInput,_mttIndex) ;' ,'\n']) ; fprintf(fid,[' }' ,'\n']) ; fprintf(fid,[' _mttTime = ssGetT(S) ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,[' ',model_name,'_get_input() ;' ,'\n']) ; fprintf(fid,[' ',model_name,'_get_state() ;' ,'\n']) ; fprintf(fid,[' ',model_name,'_ode() ;' ,'\n']) ; fprintf(fid,[' ',model_name,'_put_output() ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,[' for(_mttIndex=0; _mttIndex<_mttNumOutputs; _mttIndex++) {' ,'\n']) ; fprintf(fid,[' check_finite(S,_mttOutput,_mttIndex) ;' ,'\n']) ; fprintf(fid,[' ssGetOutputPortRealSignal(S,0)[_mttIndex] = _mttOutput[_mttIndex] ;','\n']) ; fprintf(fid,[' }' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['#define MDL_DERIVATIVES' ,'\n']) ; fprintf(fid,['static void mdlDerivatives(SimStruct *S)' ,'\n']) ; fprintf(fid,['{' ,'\n']) ; fprintf(fid,[' for (_mttIndex=0; _mttIndex<_mttNumStates; _mttIndex++) {' ,'\n']) ; fprintf(fid,[' _mttState[_mttIndex] = ssGetContStates(S)[_mttIndex] ;' ,'\n']) ; fprintf(fid,[' check_finite(S,_mttState,_mttIndex) ;' ,'\n']) ; fprintf(fid,[' }' ,'\n']) ; fprintf(fid,[' for (_mttIndex=0; _mttIndex<_mttNumInputs; _mttIndex++) {' ,'\n']) ; fprintf(fid,[' _mttInput[_mttIndex] = *ssGetInputPortRealSignalPtrs(S,0)[_mttIndex] ;','\n']) ; fprintf(fid,[' check_finite(S,_mttInput,_mttIndex) ;' ,'\n']) ; fprintf(fid,[' }' ,'\n']) ; fprintf(fid,[' _mttTime = ssGetT(S) ;' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,[' ',model_name,'_get_input() ;' ,'\n']) ; fprintf(fid,[' ',model_name,'_get_state() ;' ,'\n']) ; fprintf(fid,[' ',model_name,'_ode() ;' ,'\n']) ; fprintf(fid,[' ',model_name,'_put_derivative() ;' ,'\n']) ; fprintf(fid,[' ' ,'\n']) ; fprintf(fid,[' if (_mttTime==0)' ,'\n']) ; fprintf(fid,[' for(_mttIndex=0; _mttIndex<_mttNumStates; _mttIndex++) ssGetdX(S)[_mttIndex] = 0.0 ;','\n']) ; fprintf(fid,[' else' ,'\n']) ; fprintf(fid,[' for(_mttIndex=0; _mttIndex<_mttNumStates; _mttIndex++) {' ,'\n']) ; fprintf(fid,[' check_finite(S,_mttDerivative,_mttIndex) ;' ,'\n']) ; fprintf(fid,[' ssGetdX(S)[_mttIndex] = _mttDerivative[_mttIndex] ;' ,'\n']) ; fprintf(fid,[' }' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['static void mdlTerminate(SimStruct *S)' ,'\n']) ; fprintf(fid,['{' ,'\n']) ; fprintf(fid,[' UNUSED_ARG(S);' ,'\n']) ; fprintf(fid,[' free (_mttInput) ;' ,'\n']) ; fprintf(fid,[' free (_mttOutput) ;' ,'\n']) ; fprintf(fid,[' free (_mttState) ;' ,'\n']) ; fprintf(fid,[' free (_mttDerivative) ;' ,'\n']) ; fprintf(fid,['}' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['' ,'\n']) ; fprintf(fid,['#ifdef MATLAB_MEX_FILE' ,'\n']) ; fprintf(fid,['#include "simulink.c"' ,'\n']) ; fprintf(fid,['#else' ,'\n']) ; fprintf(fid,['#include "cg_sfun.h"' ,'\n']) ; fprintf(fid,['#endif' ,'\n']) ; |
Added mttroot/ntt/bin/trans/mttAppend.m version [18a7272424].
> > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 | function information = mttAppend(information,field,items) if isfield(information,field) previous = getfield(information,field) ; if isempty(previous) information = setfield(information,field,items) ; else information = setfield(information,field,[previous,items]) ; end else information = setfield(information,field,items) ; end |
Added mttroot/ntt/bin/trans/mttAppendFields.m version [b7b88d7113].
> > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 | function information = mttAppendFields(information,extra) if isstruct(information) & isstruct(extra) information_fields = fieldnames(information) ; extra_fields = fieldnames(extra) ; for i = 1:length(extra_fields) field_name = extra_fields{i} ; extra_field = getfield(extra,field_name) ; information = setfield(information,field_name,extra_field) ; end end |
Added mttroot/ntt/bin/trans/mttAssert.m version [0c09e28616].
> > > > > > > | 1 2 3 4 5 6 7 | function mttAssert(rule,msg) if ~isempty(rule) if ~rule error(['MTT: ',msg]) ; end end |
Added mttroot/ntt/bin/trans/mttAssign.m version [2407c65690].
> > > > > > > | 1 2 3 4 5 6 7 | function [register,ok] = mttAssign(register,new_value) if isempty(register) register = new_value ; ok = 1 ; else ok = register==new_value ; end |
Added mttroot/ntt/bin/trans/mttCheckBondgraphDeclarations.m version [6ec9682a08].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 | function mttCheckBondgraphDeclarations(model) for i = 1:length(model.sympar) mttAssert(~ismember(model.sympar{i},model.numpar),... ['Same name (',model.sympar{i},') used for "numpar" and "abg[...]" parameters']) ; mttAssert(~ismember(model.sympar{i},model.input),... ['Same name (',model.sympar{i},') used for "input" and "abg[...]" parameters']) ; end for i = 1:length(model.numpar) mttAssert(~ismember(model.numpar{i},model.input),... ['Same name (',model.numpar{i},') used for "numpar" and "input" parameters']) ; mttAssert(~ismember(model.numpar{i},model.sympar),... ['Same name (',model.numpar{i},') used for "numpar" and "abg[...]" parameters']) ; end for i = 1:length(model.input) mttAssert(~ismember(model.input{i},model.sympar),... ['Same name (',model.input{i},') used for "input" and "abg[...]" parameters']) ; mttAssert(~ismember(model.input{i},model.numpar),... ['Same name (',model.input{i},') used for "numpar" and "input" parameters']) ; end all_parameters = [] ; if ~isempty(model.sympar) all_parameters = model.sympar ; end if ~isempty(model.numpar) if isempty(all_parameters) all_parameters = model.numpar ; else all_parameters = [all_parameters, model.numpar] ; end end if ~isempty(model.input) if isempty(all_parameters) all_parameters = model.input ; else all_parameters = [all_parameters, model.input] ; end end object_names = mttGetFieldNames(model,'obj') ; if ~isempty(all_parameters) for i = 1:length(object_names) object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; for j = 1:length(object.parameter) object_parameter = object.parameter{j} ; if ~isnumeric(object_parameter) mttAssert(ismember(object_parameter,all_parameters),... ['Object parameter "',object.parameter{j},'" not previously declared']) ; end end end for j = 1:length(all_parameters) current_parameter = all_parameters{j} ; other_parameters = all_parameters ; other_parameters(j) = [] ; mttAssert(~ismember(current_parameter,other_parameters),... ['Repeated parameter/input name "',current_parameter,'"']) ; end end counter = 0 ; all_instance_parameters = [] ; for i = 1:length(object_names) object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; for j = 1:length(object.parameter) object_parameter = object.parameter{j} ; if ~isnumeric(object_parameter) counter = counter + 1 ; all_instance_parameters{counter} = object_parameter ; end end end for k = 1:length(all_parameters) parameter = all_parameters{k} ; if isempty(all_instance_parameters) mttAssert(0,['Declared parameter/input "',parameter,'" not used']) ; else mttAssert(ismember(parameter,all_instance_parameters),... ['Declared parameter/input "',parameter,'" not used']) ; end end |
Added mttroot/ntt/bin/trans/mttCheckInterfaceDeclarations.m version [2c5010e210].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | function mttCheckInterfaceDeclarations(model) for i = 1:length(model.sympar) mttAssert(~ismember(model.sympar{i},model.numpar),... ['Same name (',model.sympar{i},') used for "numpar" and "abg[...]" parameters']) ; mttAssert(~ismember(model.sympar{i},model.input),... ['Same name (',model.sympar{i},') used for "input" and "abg[...]" parameters']) ; end for i = 1:length(model.numpar) mttAssert(~ismember(model.numpar{i},model.input),... ['Same name (',model.numpar{i},') used for "numpar" and "input" parameters']) ; mttAssert(~ismember(model.numpar{i},model.sympar),... ['Same name (',model.numpar{i},') used for "numpar" and "abg[...]" parameters']) ; end for i = 1:length(model.input) mttAssert(~ismember(model.input{i},model.sympar),... ['Same name (',model.input{i},') used for "input" and "abg[...]" parameters']) ; mttAssert(~ismember(model.input{i},model.numpar),... ['Same name (',model.input{i},') used for "numpar" and "input" parameters']) ; end all_parameters = [] ; if ~isempty(model.sympar) all_parameters = model.sympar ; end if ~isempty(model.numpar) if isempty(all_parameters) all_parameters = model.numpar ; else all_parameters = [all_parameters, model.numpar] ; end end if ~isempty(model.input) if isempty(all_parameters) all_parameters = model.input ; else all_parameters = [all_parameters, model.input] ; end end object_names = mttGetFieldNames(model,'obj') ; if ~isempty(all_parameters) for i = 1:length(object_names) object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; for j = 1:length(object.parameter) object_parameter = object.parameter{j} ; if ~isnumeric(object_parameter) mttAssert(ismember(object_parameter,all_parameters),... ['Object parameter "',object.parameter{j},'" not previously declared']) ; end end end for j = 1:length(all_parameters) current_parameter = all_parameters{j} ; other_parameters = all_parameters ; other_parameters(j) = [] ; mttAssert(~ismember(current_parameter,other_parameters),... ['Repeated parameter/input name "',current_parameter,'"']) ; end end |
Added mttroot/ntt/bin/trans/mttCheckStateDeclarations.m version [3c4952b269].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | function mttCheckStateDeclarations(model) for i = 1:length(model.sympar) mttAssert(~ismember(model.sympar{i},model.state),... ['Same name (',model.sympar{i},') used for "state" and "abg[...]" parameters']) ; end for i = 1:length(model.numpar) mttAssert(~ismember(model.numpar{i},model.state),... ['Same name (',model.numpar{i},') used for "numpar" and "state" parameters']) ; end for i = 1:length(model.input) mttAssert(~ismember(model.input{i},model.state),... ['Same name (',model.input{i},') used for "input" and "state" parameters']) ; end for i = 1:length(model.state) mttAssert(~ismember(model.state{i},model.sympar),... ['Same name (',model.state{i},') used for "state" and "abg[...]" parameters']) ; mttAssert(~ismember(model.state{i},model.numpar),... ['Same name (',model.state{i},') used for "state" and "numpar" parameters']) ; mttAssert(~ismember(model.state{i},model.input),... ['Same name (',model.state{i},') used for "state" and "input" parameters']) ; end all_parameters = [] ; if ~isempty(model.sympar) all_parameters = model.sympar ; end if ~isempty(model.numpar) if isempty(all_parameters) all_parameters = model.numpar ; else all_parameters = [all_parameters, model.numpar] ; end end if ~isempty(model.input) if isempty(all_parameters) all_parameters = model.input ; else all_parameters = [all_parameters, model.input] ; end end for j = 1:length(all_parameters) current_parameter = all_parameters{j} ; mttAssert(~ismember(current_parameter,model.state),... ['Repeated parameter/state name "',current_parameter,'"']) ; end for j = 1:length(model.state) current_state = model.state{j} ; mttAssert(~ismember(current_state,all_parameters),... ['Repeated parameter/state name "',current_state,'"']) ; end |
Added mttroot/ntt/bin/trans/mttClipText.m version [69d529c0b6].
> > > > > > > > | 1 2 3 4 5 6 7 8 | function clipped_text = mttClipText(text) if isempty(text) clipped_text = [] ; else index = 1:length(text) ; useful = index(~isspace(text)) ; clipped_text = text(min(useful):max(useful)) ; end |
Added mttroot/ntt/bin/trans/mttCompare.m version [202012e558].
> > > > > > > | 1 2 3 4 5 6 7 | function comparison = mttCompare(left,right) if isempty(left) | isempty(right) comparison = [] ; else comparison = (left==right) ; end |
Added mttroot/ntt/bin/trans/mttCompareCausalCompletion.m version [52e40be8ac].
> > > > > > | 1 2 3 4 5 6 | function is_stable = mttCompareCausalCompletion(current,previous) is_stable_flow = current.flows==previous.flows ; is_stable_effort = current.efforts==previous.efforts ; is_stable = is_stable_flow & is_stable_effort ; |
Added mttroot/ntt/bin/trans/mttCompareDomainCompletion.m version [d97ae73c6a].
> > > | 1 2 3 | function is_stable = mttCompareDomainCompletion(current,previous) is_stable = current.assignments==previous.assignments ; |
Added mttroot/ntt/bin/trans/mttCompressText.m version [e7042c4298].
> > > > > > | 1 2 3 4 5 6 | function compressed_text = mttCompressText(text) if isempty(text) compressed_text = [] ; else compressed_text = text(~isspace(text)) ; end |
Added mttroot/ntt/bin/trans/mttCountObjects.m version [bbb060ad26].
> > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | function model = mttCountObjects(model) object_names = mttGetFieldNames(model,'obj') ; number_of_objects = length(object_names) ; model.count.obj = number_of_objects ; model.count.cr = 0 ; for i = 1:number_of_objects object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; if ~isempty(object.cr) model.count.cr = model.count.cr + 1 ; end if isfield(object,'obj') next = mttCountObjects(object) ; model.count.obj = model.count.obj + next.count.obj ; model.count.cr = model.count.cr + next.count.cr ; end end |
Added mttroot/ntt/bin/trans/mttCountSystemMapping.m version [70ad7bc3f3].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 | function counter = mttCountSystemMapping(model) sympars = count_system_sympars(model) ; inputs = count_system_inputs(model) ; invars = count_system_invars(model) ; outvars = count_system_outvars(model) ; states = count_system_states(model) ; counter.input = sympars + inputs + invars ; counter.output = outvars ; counter.state = states ; function counter = count_system_sympars(model) number_of_variables = mttGetFieldLength(model,'sympar') ; counter = 0 ; for i = 1:number_of_variables default_value = model.sympar_default{i} ; if isempty(default_value) counter = counter + 1 ; end end function counter = count_system_inputs(model) number_of_variables = mttGetFieldLength(model,'input') ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; additional_variables = 0 ; if ~isempty(object.abg) additional_variables = count_system_inputs(object) ; elseif ~isempty(object.cr) additional_variables = count_system_inputs(object.cr) ; end number_of_variables = number_of_variables + additional_variables ; end counter = number_of_variables ; function counter = count_system_invars(model,root,env) is_root_model = nargin==1 ; if is_root_model root = model ; env = model.env ; end number_of_variables = 0 ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; switch object.class case {'SS','Se','Sf','De','Df'} inbond_number = object.interface.in ; outbond_number = object.interface.out ; inbond = model.bond(inbond_number) ; outbond = model.bond(outbond_number) ; if ~isempty(inbond) covariables = mttGetCovariables(env,inbond.domain,inbond.domain_item) ; covar = [] ; if ~inbond.effort if ~strcmp(object.class,'Df') covar = covariables.effort ; end elseif inbond.flow if ~strcmp(object.class,'De') covar = covariables.flow ; end end number_of_variables = number_of_variables + length(covar) ; end if ~isempty(outbond) covariables = mttGetCovariables(env,outbond.domain,outbond.domain_item) ; covar = [] ; if outbond.effort covar = covariables.effort ; elseif ~outbond.flow covar = covariables.flow ; end number_of_variables = number_of_variables + length(covar) ; end end additional_variables = 0 ; if ~isempty(object.abg) additional_variables = count_system_invars(object,root,env) ; end number_of_variables = number_of_variables + additional_variables ; end counter = number_of_variables ; function counter = count_system_outvars(model,root,env) is_root_model = nargin==1 ; if is_root_model root = model ; env = model.env ; end number_of_variables = 0 ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; switch object.class case {'SS','Se','Sf','De','Df'} inbond_number = object.interface.in ; outbond_number = object.interface.out ; inbond = model.bond(inbond_number) ; outbond = model.bond(outbond_number) ; if ~isempty(inbond) covariables = mttGetCovariables(env,inbond.domain,inbond.domain_item) ; covar = [] ; if inbond.effort covar = covariables.effort ; elseif ~inbond.flow covar = covariables.flow ; end number_of_variables = number_of_variables + length(covar) ; end if ~isempty(outbond) covariables = mttGetCovariables(env,outbond.domain,outbond.domain_item) ; covar = [] ; if ~outbond.effort if ~strcmp(object.class,'Sf') covar = covariables.effort ; end elseif outbond.flow if ~strcmp(object.class,'Se') covar = covariables.flow ; end end number_of_variables = number_of_variables + length(covar) ; end end additional_variables = 0 ; if ~isempty(object.abg) additional_variables = count_system_outvars(object,root,env) ; end number_of_variables = number_of_variables + additional_variables ; end counter = number_of_variables ; function counter = count_system_states(model) number_of_variables = mttGetFieldLength(model,'state') ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; additional_variables = 0 ; if ~isempty(object.abg) additional_variables = count_system_states(object) ; elseif ~isempty(object.cr) additional_variables = count_system_states(object.cr) ; end number_of_variables = number_of_variables + additional_variables ; end counter = number_of_variables ; |
Added mttroot/ntt/bin/trans/mttCreateAlternativeEquations.m version [8fa9da4786].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 | function ese = mttCreateAlternativeEquations(model) ese = write_equations(model) ; ese = ese' ; filename = [model.source,'_ese.txt'] ; fid = fopen(filename,'w') ; fprintf(fid,['// Elementary System Equations\n']) ; fprintf(fid,'\n') ; fprintf(fid,['// file: ',filename,'\n']) ; fprintf(fid,['// written by MTT on ',datestr(now),'\n']) ; fprintf(fid,'\n\n') ; fprintf(fid,['ese ',mttDetachText(model.source,'/'),' {']) ; fprintf(fid,'\n') ; tab = char(32*ones(1,3)) ; for i = 1:length(ese) fprintf(fid,[tab,ese{i},'\n']) ; end fprintf(fid,'}') ; fclose(fid) ; function ese = write_equations(model,branch) is_root_model = (nargin==1) ; if is_root_model branch = mttDetachText(model.source,'/') ; end % ese{1} = ' ' ; % ese{2} = ['// ESE representation for module: ',branch] ; % ese{3} = ' ' ; % % line = 3 ; line = 0 ; indent = char(32*ones(1,6)) ; objects = mttGetFieldNames(model,'obj') ; for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; here = [branch,':',object_name] ; switch object.class case 'SS', for j = 1:mttGetFieldLength(object,'interface') flow_equation = [] ; effort_equation = [] ; port_name = object.interface(j).name ; inbond = object.interface(j).in ; outbond = object.interface(j).out ; if ~isempty(inbond) bond = model.bond(inbond) ; extern = [branch,'__',object_name,'___flow'] ; intern = [branch,'___f[',num2str(inbond),']'] ; if bond.flow flow_equation = [intern,' = ',extern,' ;'] ; else flow_equation = [extern,' = ',intern,' ;'] ; end extern = [branch,'__',object_name,'___effort'] ; intern = [branch,'___e[',num2str(inbond),']'] ; if bond.effort effort_equation = [extern,' = ',intern,' ;'] ; else effort_equation = [intern,' = ',extern,' ;'] ; end line = line + 1 ; ese{line} = flow_equation ; line = line + 1 ; ese{line} = effort_equation ; end if ~isempty(outbond) bond = model.bond(outbond) ; extern = [branch,'__',object_name,'___flow'] ; intern = [branch,'___f[',num2str(outbond),']'] ; if bond.flow flow_equation = [extern,' = ',intern,' ;'] ; else flow_equation = [intern,' = ',extern,' ;'] ; end extern = [branch,'__',object_name,'___effort'] ; intern = [branch,'___e[',num2str(outbond),']'] ; if bond.effort effort_equation = [intern,' = ',extern,' ;'] ; else effort_equation = [extern,' = ',intern,' ;'] ; end line = line + 1 ; ese{line} = flow_equation ; line = line + 1 ; ese{line} = effort_equation ; end end case '0', imposed_effort = [] ; resultant_flow = [] ; for i = 1:mttGetFieldLength(object,'interface') inbond = object.interface(i).in ; outbond = object.interface(i).out ; if isempty(inbond) bond_number(i) = outbond ; orientation(i) = 0 ; else bond_number(i) = inbond ; orientation(i) = 1 ; end [effort(i),flow(i)] = mttGetBondCausality(model,bond_number(i)) ; if effort(i)==orientation(i) imposed_effort_bond = bond_number(i) ; imposed_effort = [branch,'___e[',num2str(imposed_effort_bond),']'] ; end if flow(i)==orientation(i) resultant_flow_bond = bond_number(i) ; resultant_flow = [branch,'___f[',num2str(resultant_flow_bond),']'] ; end end for i = 1:mttGetFieldLength(object,'interface') if bond_number(i)~=imposed_effort_bond line = line + 1 ; derived_effort = [branch,'___e[',num2str(bond_number(i)),']'] ; ese{line} = [derived_effort,' = ',imposed_effort,' ;'] ; end end waiting = 1 ; offset = char(32*ones(1,length(resultant_flow)+1)) ; for i = 1:mttGetFieldLength(object,'interface') next_flow = [] ; if bond_number(i)~=resultant_flow_bond next_flow = [branch,'___f[',num2str(bond_number(i)),']'] ; line = line + 1 ; if waiting if orientation(i) ese{line} = [resultant_flow,' = ',next_flow] ; else ese{line} = [resultant_flow,' = -',next_flow] ; end waiting = 0 ; else if orientation(i) ese{line} = [offset,'+ ',next_flow] ; else ese{line} = [offset,'- ',next_flow] ; end end end end ese{line} = [ese{line},' ;'] ; case '1', imposed_flow = [] ; resultant_effort = [] ; for i = 1:mttGetFieldLength(object,'interface') inbond = object.interface(i).in ; outbond = object.interface(i).out ; if isempty(inbond) bond_number(i) = outbond ; orientation(i) = 0 ; else bond_number(i) = inbond ; orientation(i) = 1 ; end [effort(i),flow(i)] = mttGetBondCausality(model,bond_number(i)) ; if flow(i)~=orientation(i) imposed_flow_bond = bond_number(i) ; imposed_flow = [branch,'___f[',num2str(imposed_flow_bond),']'] ; end if effort(i)~=orientation(i) resultant_effort_bond = bond_number(i) ; resultant_effort = [branch,'___e[',num2str(resultant_effort_bond),']'] ; end end for i = 1:mttGetFieldLength(object,'interface') if bond_number(i)~=imposed_flow_bond line = line + 1 ; derived_flow = [branch,'___f[',num2str(bond_number(i)),']'] ; ese{line} = [derived_flow,' = ',imposed_flow,' ;'] ; end end waiting = 1 ; offset = char(32*ones(1,length(resultant_effort)+1)) ; for i = 1:mttGetFieldLength(object,'interface') next_effort = [] ; if bond_number(i)~=resultant_effort_bond next_effort = [branch,'___e[',num2str(bond_number(i)),']'] ; line = line + 1 ; if waiting if orientation(i) ese{line} = [resultant_effort,' = ',next_effort] ; else ese{line} = [resultant_effort,' = -',next_effort] ; end waiting = 0 ; else if orientation(i) ese{line} = [offset,'+ ',next_effort] ; else ese{line} = [offset,'- ',next_effort] ; end end end end ese{line} = [ese{line},' ;'] ; otherwise, if ~isempty(object.cr) operators = object.cr.operator ; interface = object.cr.interface ; port_names = mttGetFieldNames(interface,'port') ; link_counter = 0 ; for i = 1:length(port_names) port_name = port_names{i} ; port = getfield(interface,'port',port_name) ; terminal = [branch,'__',object_name,'___',port_name] ; inbond = port.in ; outbond = port.out ; if ~isempty(inbond) bond = model.bond(inbond) ; intern = [branch,'___f[',num2str(inbond),']'] ; if bond.flow link_counter = link_counter + 1 ; link(link_counter) = create_link(0,0,1,port_name,port.is_flow_state) ; if port.is_flow_state flow_equation = [intern,' = ',terminal,'___flow_state ;'] ; else flow_equation = [intern,' = ',terminal,'___flow ;'] ; end else link_counter = link_counter + 1 ; link(link_counter) = create_link(1,0,1,port_name,port.is_flow_state) ; if port.is_flow_state flow_equation = [terminal,'___flow_state = ',intern,' ;'] ; else flow_equation = [terminal,'___flow = ',intern,' ;'] ; end end intern = [branch,'___e[',num2str(inbond),']'] ; if bond.effort link_counter = link_counter + 1 ; link(link_counter) = create_link(1,1,0,port_name,port.is_effort_state) ; if port.is_effort_state effort_equation = [terminal,'___effort_state = ',intern,' ;'] ; else effort_equation = [terminal,'___effort = ',intern,' ;'] ; end else link_counter = link_counter + 1 ; link(link_counter) = create_link(0,1,0,port_name,port.is_effort_state) ; if port.is_effort_state effort_equation = [intern,' = ',terminal,'___effort_state ;'] ; else effort_equation = [intern,' = ',terminal,'___effort ;'] ; end end line = line + 1 ; ese{line} = flow_equation ; line = line + 1 ; ese{line} = effort_equation ; end if ~isempty(outbond) bond = model.bond(outbond) ; intern = [branch,'___f[',num2str(outbond),']'] ; if bond.flow link_counter = link_counter + 1 ; link(link_counter) = create_link(1,0,1,port_name,port.is_flow_state) ; if port.is_flow_state flow_equation = [terminal,'___flow_state = ',intern,' ;'] ; else flow_equation = [terminal,'___flow = ',intern,' ;'] ; end else link_counter = link_counter + 1 ; link(link_counter) = create_link(0,0,1,port_name,port.is_flow_state) ; if port.is_flow_state flow_equation = [intern,' = ',terminal,'___flow_state ;'] ; else flow_equation = [intern,' = ',terminal,'___flow ;'] ; end end intern = [branch,'___e[',num2str(outbond),']'] ; if bond.effort link_counter = link_counter + 1 ; link(link_counter) = create_link(0,1,0,port_name,port.is_effort_state) ; if port.is_effort_state effort_equation = [intern,' = ',terminal,'___effort_state ;'] ; else effort_equation = [intern,' = ',terminal,'___effort ;'] ; end else link_counter = link_counter + 1 ; link(link_counter) = create_link(1,1,0,port_name,port.is_effort_state) ; if port.is_effort_state effort_equation = [terminal,'___effort_state = ',intern,' ;'] ; else effort_equation = [terminal,'___effort = ',intern,' ;'] ; end end line = line + 1 ; ese{line} = flow_equation ; line = line + 1 ; ese{line} = effort_equation ; end end number_of_operators = length(operators) ; op_counter = 1 ; matching = 1 ; while matching operator = operators(op_counter) ; links = length(link) ; op_links = length(operator.link) ; op_linked = zeros(op_links,1) ; for j = 1:op_links for k = 1:links if compare_links(link(k),operator.link(j)) op_linked(j) = k ; break ; end end end input_counter = 0 ; output_counter = 0 ; input = [] ; output = [] ; if all(op_linked) for j = 1:op_links current_link = link(op_linked(j)) ; port_name = current_link.name ; if current_link.is_effort if current_link.is_state link_name = [branch,'__',object_name,'___',port_name,'___effort_state'] ; else link_name = [branch,'__',object_name,'___',port_name,'___effort'] ; end end if current_link.is_flow if current_link.is_state link_name = [branch,'__',object_name,'___',port_name,'___flow_state'] ; else link_name = [branch,'__',object_name,'___',port_name,'___flow'] ; end end if current_link.is_input input_counter = input_counter + 1 ; input{input_counter} = link_name ; else output_counter = output_counter + 1 ; output{output_counter} = link_name ; end end if input_counter>0 input_list = ['[',input{1}] ; for j = 2:input_counter input_list = [input_list,',',input{j}] ; end input_list = [input_list,']'] ; end if output_counter>0 output_list = ['[',output{1}] ; for j = 2:output_counter output_list = [output_list,',',output{j}] ; end output_list = [output_list,']'] ; end if input_counter>0 line = line + 1 ; ese{line} = [output_list,' = '] ; end line = line + 1 ; ese{line} = [indent,branch,'__',object_name,'___',operator.name] ; if output_counter>0 line = line + 1 ; ese{line} = [indent,indent,input_list,' ;'] ; end link(op_linked) = [] ; end op_counter = op_counter + 1 ; matching = ~isempty(link) & (op_counter<=number_of_operators) ; end mttAssert(isempty(link),... ['Unattached ports in "cr" implementation in ',here]) ; end end end for i = 1:length(objects) object_name = objects{i} ; object = getfield(model,'obj',object_name) ; here = [branch,':',object_name] ; if ~isempty(object.abg) for j = 1:mttGetFieldLength(object,'interface') inbond = object.interface(j).in ; outbond = object.interface(j).out ; inmap = object.interface(j).map.in ; outmap = object.interface(j).map.out ; line = line + 1 ; ese{line} = ' ' ; if ~isempty(inbond) bond = model.bond(inbond) ; extern = [branch,'__',object_name,'___f[',num2str(inmap),']'] ; intern = [branch,'___f[',num2str(inbond),']'] ; if bond.flow flow_equation = [intern,' = ',extern,' ;'] ; else flow_equation = [extern,' = ',intern,' ;'] ; end extern = [branch,'__',object_name,'___e[',num2str(inmap),']'] ; intern = [branch,'___e[',num2str(inbond),']'] ; if bond.effort effort_equation = [extern,' = ',intern,' ;'] ; else effort_equation = [intern,' = ',extern,' ;'] ; end line = line + 1 ; ese{line} = flow_equation ; line = line + 1 ; ese{line} = effort_equation ; end if ~isempty(outbond) bond = model.bond(outbond) ; extern = [branch,'__',object_name,'___f[',num2str(outmap),']'] ; intern = [branch,'___f[',num2str(outbond),']'] ; if bond.flow flow_equation = [extern,' = ',intern,' ;'] ; else flow_equation = [intern,' = ',extern,' ;'] ; end extern = [branch,'__',object_name,'___e[',num2str(outmap),']'] ; intern = [branch,'___e[',num2str(outbond),']'] ; if bond.effort effort_equation = [intern,' = ',extern,' ;'] ; else effort_equation = [extern,' = ',intern,' ;'] ; end line = line + 1 ; ese{line} = flow_equation ; line = line + 1 ; ese{line} = effort_equation ; end end next_branch = [branch,'__',object_name] ; object_ese = write_equations(object,next_branch) ; ese = [ese, object_ese] ; line = length(ese) ; end end function link = create_link(is_input,is_effort,is_flow,name,is_state) link.is_input = is_input ; link.is_effort = is_effort ; link.is_flow = is_flow ; link.name = name ; link.is_state = is_state ; function boolean = compare_links(actual_link,op_link) input_is_same = actual_link.is_input==op_link.is_input ; effort_is_same = actual_link.is_effort==op_link.is_effort ; flow_is_same = actual_link.is_flow==op_link.is_flow ; name_is_same = strcmp(actual_link.name,op_link.name) ; boolean = input_is_same & effort_is_same & flow_is_same & name_is_same ; |
Added mttroot/ntt/bin/trans/mttCutText.m version [df536d2c98].
> > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | function [left,right] = mttCutText(text,delimiter) if isempty(text) left = [] ; right = [] ; else where = min(findstr(text,delimiter)) ; if isempty(where) left = mttClipText(text) ; right = [] ; else left = mttClipText(text(1:where-1)) ; right = mttClipText(text(where+length(delimiter):length(text))) ; end end |
Added mttroot/ntt/bin/trans/mttDeleteField.m version [482e247ec2].
> > > > > > | 1 2 3 4 5 6 | function model = mttDeleteField(structure,field_name) if isfield(structure,field_name) model = rmfield(structure,field_name) ; else model = structure ; end |
Added mttroot/ntt/bin/trans/mttDetachText.m version [3bacd6b720].
> > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | function [detached_text,preceding_text] = mttDetachText(text,delimiter) if isempty(text) detached_text = [] ; preceding_text = [] ; else where = max(findstr(text,delimiter)) ; if isempty(where) detached_text = [] ; preceding_text = mttClipText(text) ; else detached_text = mttClipText(text(where+length(delimiter):length(text))) ; preceding_text = mttClipText(text(1:where-1)) ; end end |
Added mttroot/ntt/bin/trans/mttElapseTime.m version [5d0d579808].
> > > > | 1 2 3 4 | function elapsed_time = mttElapseTime(t0) current_time = mttGetTime ; elapsed_time.cpu = current_time.cpu - t0.cpu ; elapsed_time.clock = etime(current_time.clock,t0.clock) ; |
Added mttroot/ntt/bin/trans/mttExtractStatements.m version [62c7b13d82].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 | function statements = mttExtractStatements(content) input = 1 ; output = 0 ; line = [] ; searching = 0 ; processing = 1 ; while processing line = [line,content{input}] ; line = mttCutText(line,'//') ; if ~isempty(line) semicolon = findstr(line,';') ; leftbrace = findstr(line,'{') ; rightbrace = findstr(line,'}') ; terminator = sort([semicolon,leftbrace,rightbrace]) ; if isempty(terminator) searching = 1 ; else first = 1 ; N = length(terminator) ; L = length(line) ; for i = 1:N last = terminator(i) - 1 ; if first<=last output = output + 1 ; statements{output} = mttClipText(line(first:last)) ; end if ismember(line(terminator(i)),{'{','}'}) output = output + 1 ; statements{output} = line(terminator(i)) ; end first = last + 2 ; end if terminator(N)==L line = [] ; searching = 0 ; else line = mttClipText(line(terminator(N):L)) ; end end end input = input + 1 ; processing = input<=length(content) ; if searching mttAssert(input<=length(content),... 'End of file found with an incomplete statement') ; end end |
Added mttroot/ntt/bin/trans/mttExtractText.m version [18e3a1f15b].
> > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 | function extracted_text = mttExtractText(text,left,right) if isempty(text) extracted_text = [] ; else where_left = min(findstr(text,left)) ; where_right = min(findstr(text,right)) ; if ~isempty(where_left) & ~isempty(where_right) extracted_text = mttClipText(text(where_left+length(left):where_right-1)) ; else extracted_text = [] ; end end |
Added mttroot/ntt/bin/trans/mttFileExists.m version [88a67661d5].
> > > > | 1 2 3 4 | function boolean = mttFileExists(filename) boolean = exist(filename)==2 ; |
Added mttroot/ntt/bin/trans/mttFindEquationVariables.m version [448d87faf7].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 | function [varlist,location] = mttFindEquationVariables(line) line = mttClipText(line) ; if isempty(line) namelist = [] ; location = [] ; else numbers = (line>=48 & line<=57) ; letters = (line>=65 & line<=90)|(line>=97 & line<=122) ; underscores = (line==95) ; dots = (line==46) ; apostrophes = (line==39) ; mask = (numbers|letters|underscores|dots|apostrophes) ; buffer = line ; buffer(~mask) = char(32*ones(1,sum(~mask))) ; next = 1 ; last = length(buffer) ; counter = 0 ; finding = any(mask) ; while finding i = min(find(~isspace(buffer(next:last))))+next-1 ; if isempty(i) finding = 0 ; else if i>last finding = 0 ; else if i==last j = last ; else j = min(find(isspace(buffer(i+1:last))))+i ; if isempty(j) j = last ; else j = j - 1 ; end end if ~mttIsNumericText(buffer(i:j)) var_found = 1 ; if j<last jj = min(find(~isspace(line(j+1:last))))+j ; if line(jj)=='(' var_found = 0 ; end end if var_found counter = counter + 1 ; varlist{counter} = buffer(i:j) ; location(counter) = i ; end end next = j + 1 ; finding = (next<last) & ~isempty(i) ; end end end end |
Added mttroot/ntt/bin/trans/mttGetBondCausality.m version [e62609931f].
> > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 | function [effort_causality,flow_causality,uni_causality] = mttGetBondCausality(model,bond_number) if isempty(bond_number) effort_causality = [] ; flow_causality = [] ; uni_causality = [] ; else effort_causality = model.bond(bond_number).effort ; flow_causality = model.bond(bond_number).flow ; uni_causality = model.bond(bond_number).unicausal ; end |
Added mttroot/ntt/bin/trans/mttGetBondDomain.m version [b0febc628a].
> > > > > > > > | 1 2 3 4 5 6 7 8 | function [domain,domain_item] = mttGetBondDomain(model,bond_number) if isempty(bond_number) domain = [] ; domain_item = [] ; else domain = model.bond(bond_number).domain ; domain_item = model.bond(bond_number).domain_item ; end |
Added mttroot/ntt/bin/trans/mttGetCovariables.m version [5ae2548ed6].
> > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 | function covariables = mttGetCovariables(env,domain,domain_item) if isempty(domain) covariables.effort = {'effort'} ; covariables.flow = {'flow'} ; covariables.effort_default = {[]} ; covariables.flow_default = {[]} ; else covariables = getfield(env,'public_domain',{domain},'item',domain_item) ; end |
Added mttroot/ntt/bin/trans/mttGetField.m version [93d11ba8da].
> > > > > | 1 2 3 4 5 | function field = mttGetField(structure,component) field = [] ; if isfield(structure,component) field = getfield(structure,component) ; end |
Added mttroot/ntt/bin/trans/mttGetFieldLength.m version [ffab5c2924].
> > > > > | 1 2 3 4 5 | function N = mttGetFieldLength(structure,vector) N = 0 ; if isfield(structure,vector) N = length(getfield(structure,vector)) ; end |
Added mttroot/ntt/bin/trans/mttGetFieldNames.m version [371982056a].
> > > > > > > > > | 1 2 3 4 5 6 7 8 9 | function namelist = mttGetFieldNames(structure,component) namelist = [] ; if isfield(structure,component) field = getfield(structure,component) ; if ~isempty(field) namelist = fieldnames(field) ; end end |
Added mttroot/ntt/bin/trans/mttGetInstanceParameters.m version [12b70a7300].
> > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 | function parameters = mttGetInstanceParameters(parameter_list) parameters = mttGetItemList(parameter_list) ; for n = 1:length(parameters) if mttIsNumericText(parameters{n}) parameters{n} = str2num(parameters{n}) ; else mttValidateName(parameters{n}) ; end end |
Added mttroot/ntt/bin/trans/mttGetItemList.m version [52367110b3].
> > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | function [items,item_values] = mttGetItemList(text) if isempty(text) items = [] ; item_values = [] ; else counter = 0 ; fetching_items = 1 ; while fetching_items counter = counter + 1 ; [next_item,text] = mttCutText(text,',') ; [item_name,item_value] = mttCutText(next_item,'=') ; items{counter} = item_name ; item_values{counter} = item_value ; if isempty(text) fetching_items = 0 ; end end end |
Added mttroot/ntt/bin/trans/mttGetParameters.m version [d7054c9547].
> > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | function [parameters,default_values] = mttGetParameters(parameter_list) [parameters,default_values] = mttGetItemList(parameter_list) ; for n = 1:length(parameters) parameter_name = parameters{n} ; mttValidateName(parameter_name) ; end for n = 1:length(default_values) default_value = default_values{n} ; if ~isempty(default_value) mttAssert(mttIsNumericText(default_value),... 'Parameter list contains non-numeric default value') ; end end |
Added mttroot/ntt/bin/trans/mttGetTime.m version [db639d211d].
> > > | 1 2 3 | function time = mttGetTime time.clock = clock ; time.cpu = cputime ; |
Added mttroot/ntt/bin/trans/mttIdentifyImplicitBonds.m version [06bec7e6fc].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 | function next_next = mttIdentifyImplicitBonds(model,branch,next) is_root_model = (nargin==1) ; if is_root_model mttNotify('...following bonds have no explicit domain allocation:') ; mttWriteNewLine ; branch = mttDetachText(model.source,'/') ; next = 0 ; end number_of_bonds = mttGetFieldLength(model,'bond') ; for i = 1:number_of_bonds if isempty(model.bond(i).domain) origin = model.bond(i).from.obj ; port = model.bond(i).from.interface ; if isfield(model.obj,origin) origin_class = getfield(model,'obj',origin,'class') ; switch origin_class case {'0','1'}, bond_origin = [origin_class,':',origin] ; otherwise, origin_port = getfield(model,'obj',origin,'interface',{port},'name') ; bond_origin = [origin_class,':',origin,'[',origin_port,']'] ; end else bond_origin = ['SS:',origin] ; end target = model.bond(i).to.obj ; port = model.bond(i).to.interface ; if isfield(model.obj,target) target_class = getfield(model,'obj',target,'class') ; switch target_class case {'0','1'}, bond_target = [target_class,':',target] ; otherwise, target_port = getfield(model,'obj',target,'interface',{port},'name') ; bond_target = [target_class,':',target,'[',target_port,']'] ; end else bond_target = ['SS:',target] ; end next = next + 1 ; descriptor = [' ',num2str(next),': ',branch,'(',num2str(i),') from: ',... bond_origin,' to: ',bond_target] ; mttNotify(descriptor) ; mttWriteNewLine ; end end next_next = next ; object_names = mttGetFieldNames(model,'obj') ; number_of_objects = length(object_names) ; for i = 1:number_of_objects object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; if isfield(object,'obj') next_branch = [branch,'/',object_name] ; next_next = mttIdentifyImplicitBonds(object,next_branch,next) ; next = next_next ; end end |
Added mttroot/ntt/bin/trans/mttIdentifySource.m version [333fd4e482].
> > > > > > > | 1 2 3 4 5 6 7 | function [directory,file] = mttIdentifySource(local_filename) local_filename filename = which(local_filename) backslash = findstr(filename,'\') ; filename(backslash) = '/' ; [file,directory] = mttDetachText(filename,'/') ; |
Added mttroot/ntt/bin/trans/mttIdentifyUndercausalBonds.m version [b4813b7312].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 | function next_next = mttIdentifyUndercausalBonds(model,branch,next) is_root_model = (nargin==1) ; if is_root_model mttNotify('...following bonds are under-causal:') ; mttWriteNewLine ; branch = mttDetachText(model.source,'/') ; next = 0 ; end number_of_bonds = mttGetFieldLength(model,'bond') ; for i = 1:number_of_bonds if isempty(model.bond(i).effort) | isempty(model.bond(i).flow) origin = model.bond(i).from.obj ; port = model.bond(i).from.interface ; if isfield(model.obj,origin) origin_class = getfield(model,'obj',origin,'class') ; switch origin_class case {'0','1'}, bond_origin = [origin_class,':',origin] ; otherwise, origin_port = getfield(model,'obj',origin,'interface',{port},'name') ; bond_origin = [origin_class,':',origin,'[',origin_port,']'] ; end else bond_origin = ['SS:',origin] ; end target = model.bond(i).to.obj ; port = model.bond(i).to.interface ; if isfield(model.obj,target) target_class = getfield(model,'obj',target,'class') ; switch target_class case {'0','1'}, bond_target = [target_class,':',target] ; otherwise, target_port = getfield(model,'obj',target,'interface',{port},'name') ; bond_target = [target_class,':',target,'[',target_port,']'] ; end else bond_target = ['SS:',target] ; end next = next + 1 ; descriptor = [' ',num2str(next),': ',branch,'(',num2str(i),') from: ',... bond_origin,' to: ',bond_target] ; mttNotify(descriptor) ; mttWriteNewLine ; end end next_next = next ; object_names = mttGetFieldNames(model,'obj') ; number_of_objects = length(object_names) ; for i = 1:number_of_objects object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; if isfield(object,'obj') next_branch = [branch,'/',object_name] ; next_next = mttIdentifyUndercausalBonds(object,next_branch,next) ; next = next_next ; end end |
Added mttroot/ntt/bin/trans/mttIdentifyUserDomain.m version [c4859d1958].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | function user_domain_identification = mttIdentifyUserDomain(environment,domain,domain_item) user_domain_identification = [] ; if ~(isempty(domain) | isempty(domain_item)) user_domain_names = mttGetFieldNames(environment,'domain') ; number_of_user_domains = length(user_domain_names) ; counter = 0 ; identifying = 1 ; while identifying counter = counter + 1 ; user_domain_name = user_domain_names{counter} ; user_domain = getfield(environment,'domain',user_domain_name) ; specified_domain = user_domain.dom ; specified_domain_item = user_domain.item ; if domain==specified_domain if ~isempty(domain_item) if isempty(specified_domain_item) domain_item_names = mttGetFieldNames(environment.public_domain(domain),'item') ; is_valid_item = ismember(domain_item,domain_item_names) ; if is_valid_item user_domain_identification = [user_domain_name,'__',domain_item] ; end else is_matched_item = strcmp(domain_item,specified_domain_item) ; if is_matched_item user_domain_identification = user_domain_name ; end end end end identifying = (counter<number_of_user_domains) & isempty(user_domain_identification) ; end end |
Added mttroot/ntt/bin/trans/mttIsEmptyCellArray.m version [39b20a02b5].
> > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 | function boolean = mttIsEmptyCellArray(cell_array) boolean = [] ; if iscell(cell_array) boolean = 1 ; for i = 1:length(cell_array) if ~isempty(cell_array{i}) boolean = 0 ; end end end |
Added mttroot/ntt/bin/trans/mttIsEqual.m version [6c0e6f54d5].
> > > > > > > | 1 2 3 4 5 6 7 | function result = mttIsEqual(left,right) if ~isempty(left) & ~isempty(right) result = left==right ; else result = [] ; end |
Added mttroot/ntt/bin/trans/mttIsFoundationClass.m version [33607d1580].
> > > > | 1 2 3 4 | function boolean = mttIsFoundationClass(class_name) boolean = ismember(class_name,... {'R','C','I','TF','GY','AE','AF','SS','Se','Sf','De','Df','0','1'}) ; |
Added mttroot/ntt/bin/trans/mttIsNumericText.m version [8cd049d628].
> > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | function boolean = mttIsNumericText(text) if any(abs(text)==39) % MATLAB doesn't like apostrophes in text boolean = 0 ; elseif strcmp(text,'flow') % MATLAB invokes built-in function "flow" rather than treating it as text in str2num(text) !!! boolean = 0 ; elseif strcmp(text,'error') % MATLAB invokes built-in function "error" rather than treating it as text in str2num(text) !!! boolean = 0 ; else num = str2num(text) ; if isempty(num) boolean = 0 ; % ... contains non-numeric characters other than stand-alone "i" or "j" else boolean = isreal(num) ; % ... doesn't contain stand-alone "i" or "j" end end |
Added mttroot/ntt/bin/trans/mttIsPassiveClass.m version [e8bd676573].
> > | 1 2 | function boolean = mttIsPassiveClass(class_name) boolean = ismember(class_name,{'SS','Se','Sf','De','Df','0','1'}) ; |
Added mttroot/ntt/bin/trans/mttIsPortClass.m version [5ddeb3fb33].
> > | 1 2 | function boolean = mttIsPortClass(class_name) boolean = ismember(class_name,{'SS','Se','Sf','De','Df'}) ; |
Added mttroot/ntt/bin/trans/mttLocateDirectory.m version [4faff0628d].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 | function directory = mttLocateDirectory(working_directory,local_directory) if isempty(local_directory) directory = working_directory ; else backslash = findstr(working_directory,'\') ; working_directory(backslash) = '/' ; [working_drive,working_path] = mttCutText(working_directory,':') ; if isempty(working_path) working_path = working_directory ; working_drive = [] ; end [local_drive,local_path] = mttCutText(local_directory,':') ; if isempty(local_path) local_path = local_directory ; local_drive = [] ; end if isempty(local_drive) if local_path(1)=='/' if isempty(working_drive) directory = local_path ; else directory = [working_drive,':',local_path] ; end else directory = [working_directory,'/',local_directory] ; end else mttAssert(all(isletter(local_drive)),... ['"',local_drive,'" is an invalid drive specifier']) ; directory = local_directory ; end mttAssert(exist(directory,'dir')==7,... ['Directory "',directory,'" not found']) ; locating = 1 ; while locating [left,right] = mttCutText(directory,'//') ; if isempty(right) locating = 0 ; else directory = [left,'/',right] ; end end locating = 1 ; while locating backtrack = findstr(directory,'/..') ; if isempty(backtrack) locating = 0 ; else [left,right] = mttCutText(directory,'/..') ; if isempty(right) [cancelled,left] = mttDetachText(left,'/') ; directory = left ; else [cancelled,left] = mttDetachText(left,'/') ; directory = [left,right] ; end end end end |
Added mttroot/ntt/bin/trans/mttMeasureCausalCompletion.m version [0f88a2574d].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | function model = mttMeasureCausalCompletion(model) number_of_bonds = mttGetFieldLength(model,'bond') ; for i = 1:number_of_bonds effort_defined(i) = ~isempty(model.bond(i).effort) ; flow_defined(i) = ~isempty(model.bond(i).flow) ; end partly_defined = effort_defined|flow_defined ; fully_defined = effort_defined&flow_defined ; causal_completion.bonds = number_of_bonds ; causal_completion.flows = sum(flow_defined) ; causal_completion.efforts = sum(effort_defined) ; causal_completion.assignments = sum(partly_defined) ; unicausal_bonds = 0 ; causal_bond = model.bond(fully_defined) ; for i = 1:length(causal_bond) if causal_bond(i).effort==causal_bond(i).flow unicausal_bonds = unicausal_bonds + 1 ; end end causal_completion.unicausal = unicausal_bonds ; causal_completion.is_unicausal = causal_completion.assignments==causal_completion.unicausal ; causal_completion.is_causal = (causal_completion.efforts==causal_completion.bonds) ... & (causal_completion.flows==causal_completion.bonds) ; object_names = mttGetFieldNames(model,'obj') ; number_of_objects = length(object_names) ; for i = 1:number_of_objects object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; if ~isempty(object.abg) object = mttMeasureCausalCompletion(object) ; causal_completion.bonds = causal_completion.bonds + object.causal_completion.bonds ; causal_completion.flows = causal_completion.flows + object.causal_completion.flows ; causal_completion.efforts = causal_completion.efforts + object.causal_completion.efforts ; causal_completion.assignments = causal_completion.assignments + object.causal_completion.assignments ; causal_completion.unicausal = causal_completion.unicausal + object.causal_completion.unicausal ; causal_completion.is_unicausal = causal_completion.is_unicausal & object.causal_completion.is_unicausal ; causal_completion.is_causal = causal_completion.is_causal & object.causal_completion.is_causal ; end end model.causal_completion = causal_completion ; |
Added mttroot/ntt/bin/trans/mttMeasureDomainCompletion.m version [ba3a2087d1].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | function model = mttMeasureDomainCompletion(model) number_of_bonds = mttGetFieldLength(model,'bond') ; for i = 1:number_of_bonds domain_defined(i) = ~isempty(model.bond(i).domain) ; end domain_completion.bonds = number_of_bonds ; domain_completion.assignments = sum(domain_defined) ; domain_completion.is_done = (domain_completion.bonds==domain_completion.assignments) ; object_names = mttGetFieldNames(model,'obj') ; number_of_objects = length(object_names) ; for i = 1:number_of_objects object_name = object_names{i} ; object = getfield(model,'obj',object_name) ; if ~isempty(object.abg) object = mttMeasureDomainCompletion(object) ; domain_completion.bonds = domain_completion.bonds + object.domain_completion.bonds ; domain_completion.assignments = domain_completion.assignments + object.domain_completion.assignments ; domain_completion.is_done = domain_completion.is_done & object.domain_completion.is_done ; end end model.domain_completion = domain_completion ; |
Added mttroot/ntt/bin/trans/mttNotify.m version [f0a2b33349].
> > > | 1 2 3 | function mttNotify(msg) fprintf(msg) ; |
Added mttroot/ntt/bin/trans/mttNotifyCausalCompletion.m version [e3901e9d39].
> > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | function mttNotifyCausalCompletion(model) flow = floor(100*model.causal_completion.flows/model.causal_completion.bonds) ; effort = floor(100*model.causal_completion.efforts/model.causal_completion.bonds) ; unicausal = model.causal_completion.unicausal/model.causal_completion.bonds ; if model.causal_completion.is_unicausal fprintf([' ...causality is %i%% complete [%i/%i]: all unicausal\n'],... flow,model.causal_completion.assignments,model.causal_completion.bonds) ; else fprintf([' .....flow causality is %i%% complete [%i/%i]\n'],... flow,model.causal_completion.flows,model.causal_completion.bonds) ; fprintf([' ...effort causality is %i%% complete [%i/%i]\n'],... effort,model.causal_completion.efforts,model.causal_completion.bonds) ; fprintf([' => %i bonds are unicausal\n'],... model.causal_completion.unicausal) ; end |
Added mttroot/ntt/bin/trans/mttNotifyDomainCompletion.m version [532186cac8].
> > > > > > | 1 2 3 4 5 6 | function mttNotifyDomainCompletion(model) domain = floor(100*model.domain_completion.assignments/model.domain_completion.bonds) ; fprintf([' ...domain allocation is %i%% complete [%i/%i]\n'],... domain,model.domain_completion.assignments,model.domain_completion.bonds) ; |
Added mttroot/ntt/bin/trans/mttNotifyEquationSort.m version [5bdea2a945].
> > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | function is_complete = mttNotifyEquationSort(sort_iteration,... number_of_unsorted_equations,number_of_equations,... number_of_known_covariables,number_of_covariables,... number_of_known_interface_variables,number_of_interface_variables) ; % number_of_known_covariables = number_of_known_covariables - 1 ; number_of_known_interface_variables = number_of_known_interface_variables - 1 ; number_of_sorted_equations = number_of_equations - number_of_unsorted_equations ; sorted = floor(100*number_of_sorted_equations/number_of_equations) ; covar = floor(100*number_of_known_covariables/number_of_covariables) ; interface_var = floor(100*number_of_known_interface_variables/number_of_interface_variables) ; fprintf([' ...%i%% complete [%i/%i]\n'],... sorted,number_of_sorted_equations,number_of_equations) ; fprintf([' matching %i%% co_variables [%i/%i] and'],... covar,number_of_known_covariables,number_of_covariables) ; fprintf([' %i%% interface_variables [%i/%i]\n'],... interface_var,number_of_known_interface_variables,number_of_interface_variables) ; is_complete = (sorted==100) & (covar==100) & (interface_var==100) ; |
Added mttroot/ntt/bin/trans/mttNotifyEquationSortProblems.m version [422f8ebbc4].
> > > > > > > | 1 2 3 4 5 6 7 | function mttNotifyEquationSortProblems(name_known,namelist) fprintf(' ...undetermined interface_variables are:\n') ; for i = 2:length(namelist) if ~name_known(i) fprintf([' ',namelist{i},'\n']) ; end end |
Added mttroot/ntt/bin/trans/mttNotifyEquationSummary.m version [a1f8988b05].
> > > > > > > | 1 2 3 4 5 6 7 | function mttNotifyEquationSummary(number_of_equations,number_of_covariables,number_of_interface_variables) mttNotify([' ...model has ',num2str(number_of_equations),' equations']) ; mttWriteNewLine ; mttNotify([' with ',num2str(number_of_covariables),' co_variables']) ; mttNotify([' and ',num2str(number_of_interface_variables),' interface_variables']) ; mttWriteNewLine ; |
Added mttroot/ntt/bin/trans/mttNotifyNumberOfBonds.m version [edfe090ab6].
> > > > | 1 2 3 4 | function mttNotifyOfBonds(model) number_of_bonds = model.causal_completion.bonds ; fprintf(' ...model has %i bonds',number_of_bonds) ; |
Added mttroot/ntt/bin/trans/mttNotifyNumberOfObjects.m version [a3f2f2c77b].
> > > > > | 1 2 3 4 5 | function mttNotifyOfObjects(model) number_of_objects = model.count.obj ; number_of_crs = model.count.cr ; fprintf(' ...model has %i active objects (%i implemented by CRs)',number_of_objects,number_of_crs) ; |
Added mttroot/ntt/bin/trans/mttReadFile.m version [37968e6d57].
> > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | function content = mttReadFile(filename) file_exists = exist(filename)==2 ; if file_exists fid = fopen(filename,'r') ; reading = 1 ; counter = 0 ; while reading line = fgetl(fid) ; if ~isempty(line) if line==-1 reading = 0 ; else counter = counter + 1 ; content{counter} = line ; end end end fclose(fid) ; else error(['file_not_found[',filename,']']) end |
Added mttroot/ntt/bin/trans/mttSeparateText.m version [4f00712084].
> > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | function [left,right] = mttSeparateText(text) if isempty(text) left = [] ; right = [] ; else whitespace = min(find(isspace(text))) ; if isempty(whitespace) left = text ; right = [] ; else left = text(1:whitespace-1) ; right = mttClipText(text(whitespace+1:length(text))) ; end end |
Added mttroot/ntt/bin/trans/mttSetFieldDefault.m version [5626026953].
> > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 | function structure = mttSetFieldDefault(structure,component,value) undefined = 0 ; if isfield(structure,component) undefined = isempty(getfield(structure,component)) ; else undefined = 1 ; end if undefined structure = setfield(structure,component,value) ; end |
Added mttroot/ntt/bin/trans/mttUpdateBondCausality.m version [f0b400b32e].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 | %function [model,bond_not_failed,diagnostic] = mttUpdateBondCausality(... % model,bond_number,effort_causality,flow_causality,uni_causality) function [model,bond_not_failed] = mttUpdateBondCausality(... model,bond_number,effort_causality,flow_causality,uni_causality) if isempty(bond_number) bond_not_failed = 1 ; % diagnostic = [] ; else [model.bond(bond_number).effort,effort_ok] = ... update_causality(model.bond(bond_number).effort,effort_causality) ; [model.bond(bond_number).flow,flow_ok] = ... update_causality(model.bond(bond_number).flow,flow_causality) ; [model.bond(bond_number).unicausal,unicausal_ok] = ... update_causality(model.bond(bond_number).unicausal,uni_causality) ; [model.bond(bond_number),unicausal_checked] = ... check_unicausal(model.bond(bond_number)) ; bond_not_failed = effort_ok & flow_ok & unicausal_ok & unicausal_checked ; % diagnostic = [effort_ok,flow_ok,unicausal_ok,unicausal_checked] ; end function [value,ok] = update_causality(value,new_value) ok = 1 ; if ~isempty(new_value) if isempty(value) value = new_value ; else ok = value==new_value ; end end function [bond,ok] = check_unicausal(bond) unicausal_defined = ~isempty(bond.unicausal) ; effort_defined = ~isempty(bond.effort) ; flow_defined = ~isempty(bond.flow) ; ok = 1 ; if unicausal_defined switch bond.unicausal case 0, if effort_defined & flow_defined ok = bond.effort==~bond.flow ; elseif effort_defined & ~flow_defined bond.flow = ~bond.effort ; elseif flow_defined & ~effort_defined bond.effort = ~bond.flow ; end case 1, if effort_defined & flow_defined ok = bond.effort==bond.flow ; elseif effort_defined & ~flow_defined bond.flow = bond.effort ; elseif flow_defined & ~effort_defined bond.effort = bond.flow ; end end end |
Added mttroot/ntt/bin/trans/mttUpdateBondDomain.m version [04cf4f8e59].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | function [model,bond_not_failed] = mttUpdateBondDomain(... model,bond_number,imposed_domain,imposed_domain_item) if isempty(bond_number) bond_not_failed = 1 ; else [model.bond(bond_number).domain,domain_ok] = ... update_domain(model.bond(bond_number).domain,imposed_domain) ; if domain_ok [model.bond(bond_number).domain_item,domain_item_ok] = ... update_domain_item(model.bond(bond_number).domain_item,imposed_domain_item) ; else domain_item_ok = 0 ; end bond_not_failed = domain_ok & domain_item_ok ; end function [value,ok] = update_domain(value,new_value) ok = 1 ; if ~isempty(new_value) if isempty(value) value = new_value ; else ok = value==new_value ; end end function [value,ok] = update_domain_item(value,new_value) ok = 1 ; if ~isempty(new_value) if isempty(value) value = new_value ; else ok = strcmp(value,new_value) ; end end |
Added mttroot/ntt/bin/trans/mttValidateName.m version [b841cdc721].
> > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | function mttValidateName(name) mttAssert(~isempty(name),'Empty name') ; numbers = (name>=48 & name<=57) ; letters = (name>=65 & name<=90)|(name>=97 & name<=122) ; underscores = (name==95) ; is_alphanumeric = all(numbers|letters|underscores) ; starts_with_letter = isletter(name(1)) ; valid_name = is_alphanumeric & starts_with_letter ; % mtt_prefix = strncmp(name,'mtt_',4) ; mtt_delimiter = ~isempty(findstr(name,'__')) ; % mttAssert(~mtt_prefix,['"',name,'" must not contain "mtt_" prefix']) ; mttAssert(~mtt_delimiter,['"',name,'" must not contain contiguous "_" delimiters']) ; mttAssert(valid_name,['"',name,'" is not a valid name']) ; mttAssert(length(name)<32,['"',name,'" must be shortened to less than 32 characters']) ; |
Added mttroot/ntt/bin/trans/mttVerifyAlternativeEquations.m version [c872db1223].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | function delta = mttVerifyEquations(primary,secondary) searching = 1 ; length_primary = length(primary) ; length_secondary = length(secondary) ; i = 1 ; j = 1 ; k = 1 ; fprintf('k=%i: i=%i j=%i L=%i\n',k,i,j,length_secondary) ; while searching k = k + 1 ; if strcmp(primary(i),secondary(j)) secondary(j) = [] ; length_secondary = length_secondary - 1 ; fprintf('k=%i: i=%i j=%i L=%i\n',k,i,j,length_secondary) ; i = i + 1; j = 1 ; else j = j + 1 ; end if length_secondary<1 searching = 0 ; elseif j>length_secondary i = i + 1 ; j = 1 ; end if i>length_primary searching = 0 ; end end delta = secondary ; fprintf('Verification complete after %i iterations\n',k) ; fprintf('...%i new records found\n',length(delta)) ; |
Added mttroot/ntt/bin/trans/mttWriteNewLine.m version [252139e429].
> > > | 1 2 3 | function mttWriteNewLine fprintf('\n') ; |