I'm trying to simulate cooling of cylinder-shaped sample, but when I submit a job I get an error: stress-displacement elements are not allowed in a heat transfer analysis. I defined part, material(density, specific heat, conductivity), section, section assignments, mesh, instance, predefined field (temperature) in initial step, step-1 (heat transfer) with interaction (surface film condition). Where's the problem ?
Update:
I solved that problem: I had an incorrect element type. For the heat transfer simulation: Mesh -> Element Type -> Family -> Heat Transfer. I guess that also Convection/Diffusion option in the Hex tab should be selected.
Related
I need some help in creating a VI that generates virtual or calculated channels based on several channels I measure.
e.g.
I measure voltage on several AI, lets say, ch A,B,C,D,E were B,C and E represent current on a shunt and would like to calculate a the power of the system
Q[A] = B+C
R[W] = A*Q
S[W] = D*E
T[W] = R+S
I would like to load the equations externally from a configuration file that may vary from one project to another equations would come in a format of a string Q=A+B , R= A*Q .....
*(during a run equation and channel count don't change - only when loading config).
The main issues that I am facing is that the inputs to each equation may have dependencies on virtual channels that do not have data yet
Was trying to use:
formula nodes/ Math scripts: https://zone.ni.com/reference/en-XX/help/371361R-01/lvconcepts/formula_nodes/
https://knowledge.ni.com/KnowledgeArticleDetails?id=kA03q000000x30HCAQ&l=en-IL
All data that should be chunked into a data stream (continues sampling) that can be presented on a Chart/Graph and saved to CSV/TDMS
do I need some additional packages?
I have tried the following based on the the example given - getting strange result
Answer
The elements you are looking for are not the Formula/Math Nodes but rather the:
Formula Parsing VIs
Using these VIs you are able to pass a calculation in the form of a string and an array of variable names and then evaluate the formula. This allows for run-time variable scripting, where most other nodes require compile time formula evaluation (With the exception of the python node).
Example
Example of using a very simple program to evaluate two different calculations using the same values and variables.
Any items in a list where the name of an item (in the brackets) has <=2 character, the description is put on the same line as the name. I'm looking for a way to make it so all of the descriptions are all indented on the next line, thanks.
\documentclass[11pt]{article}
%% Layout Alteration
%% --------------------------
\usepackage{
enumitem, % indented items for glossary
framed, % nice boxes; used in Supervisor's Approval
geometry, % change the margins for specific PAGES
}
\setlist[description]{style=nextline}
\geometry{ % specify page size options for (geometry)
a4paper, % paper size
margin=1in, % specified independently with hmargin vmargin
}
% Hides the formatting for the glossary
\newenvironment{Glossary}
{
\begin{description}
}
{
\end{description}
}
\begin{document}
\begin{Glossary}
\item[Uvic] University of Victoria
\item[2-FSK] 2 tone Frequency Shift Keying
\item[Core blocks] The pre installed modules and blocks in Gnuradio
\item[CSA] Canadian Space Agency
\item[CubeSat] A miniaturized space satellite for research
\item[DSP] Digital Signal Processor
\item[FM] Frequency Modulation
\item[FPGA] Field-Programmable Gate Array
\item[FSK] Frequency Shift Keying
\item[GFSK] Gaussian Frequency Shift Keying
\item[GNU Radio] A DSP and SDR creation software
\item[GPIO] General Purpose Input/Output
\item[GRC] GNU Radio Companion, GUI interface for GNU Radio
\item[gr\_modtool] A script that simplifies the process of creating OOT Modules
\item[GUI] Graphical User Interface
\item[IO] Input/Output
\item[OS] Operating System
\item[OOT Module] Out-of-tree Module
\item[PDU] Protocol Data Unit, A PMT that is a pair of a dictionary and a uniform vector type
\item[PMT] Polymorphic Type, An opaque data type designed as generic containers of data that can be safely passed between blocks in Gnuradio
\end{Glossary}
\end{document}
"FM", "IO, and "OS" names all have their descriptions on the same line
There are a couple of options. For example: Format the item yourself with a new command. Then you can decide the spacing yourself.
\newcommand{\myitem}[2]{
\item[] \textbf{#1} \newline \hspace*{.5cm} #2}
\begin{document}
\begin{Glossary}
\myitem{Uvic} University of Victoria
\myitem{2-FSK} 2 tone Frequency Shift Keying
\myitem{Core blocks} The pre installed modules and blocks in Gnuradio
\myitem{CSA} Canadian Space Agency
\myitem{CubeSat} A miniaturized space satellite for research
\myitem{DSP} Digital Signal Processor
\myitem{FM} Frequency Modulation
\myitem{FPGA} Field-Programmable Gate Array
\myitem{FSK} Frequency Shift Keying
\myitem{GFSK} Gaussian Frequency Shift Keying
\myitem{GNU Radio} A DSP and SDR creation software
\myitem{GPIO} General Purpose Input/Output
\myitem{GRC} GNU Radio Companion, GUI interface for GNU Radio
\myitem{gr\_modtool} A script that simplifies the process of creating OOT Modules
\myitem{GUI} Graphical User Interface
\myitem{IO} Input/Output
\myitem{OS} Operating System
\myitem{OOT Module} Out-of-tree Module
\myitem{PDU} Protocol Data Unit, A PMT that is a pair of a dictionary and a uniform vector type
\myitem{PMT} Polymorphic Type, An opaque data type designed as generic containers of data that can be safely passed between blocks in Gnuradio
\end{Glossary}
Gives you this (excerpt):
An even simpler (but hacky) solution is to just insert invisible letters in the shorter items to match the longer ones and thereby force the same formatting:
\item[GUI] Graphical User Interface
\item[IO\phantom{XYZ}] Input/Output
\item[OS\phantom{XYZ}] Operating System
And better yet, organize your acronyms using a package that does the formatting and bookkeeping for you, e.g. acro.
I have a pdb file that is a subset of a much larger system. This pdb is special because I have some vectors based on this file's coordinate system. I want to draw these vectors and the basis vector of that system onto the pdb. Eventually I would like to visualize the vector and basis vectors as it moves through some MD simulation where I an update the vector position based on the trajectory over time.
To start, I would like to read a pdb that has coordinates that define the basis vectors that further define the other vectors I want to visualize. Right now I'm using this class in MDAnalysis:
https://docs.mdanalysis.org/1.0.0/_modules/MDAnalysis/coordinates/PDB.html#PDBReader
molecule=mda.coordinates.PDB.PDBReader('molecule.pdb')
This works and it reads the pdb just fine, but returns with this variable type
coordinates.PDB.Reader
I suppose this isn't a surprise, but I want to be able to print this variable and get some array of coordinate positions and atom types. I'd love to see the bonds as well but that's not necessary. Now when I print I get
<PDBReader molecule.pdb with 1 frames of 60 atoms>
I want something that would look like
[atomtype1,x1,y1,z1]...[atomtypen,xn,yn,zn]
Thank you,
Loading data: Universe
To get the coordinates in MDAnalysis you first load a Universe (you don't normally use the coordinate readers directly):
import MDAnalysis as mda
u = mda.Universe('molecule.pdb')
The Universe contains "topology" (atom types, bonds if available, etc) and the "trajectory" (i.e., coordinates).
Accessing per-atom data: Universe.atoms
All the atoms are stored in u.atoms (they form an AtomGroup). All information about the atoms is available from an AtomGroup. For example, all positions are available as a numpy array with
u.atoms.positions
The names are
u.atoms.names
and there are many more attributes. (The same works for residues: u.residues or u.atoms.residues gives the residues. You can also slice/index an AtomGroup to get a new AtomGroup. For example, the residues that belong to the first 20 atoms are u.atoms[:20].residues... AtomGroups are the key to working with MDAnalysis.)
Extracting atom names and positions
To build the list that you asked for:
names_positions = [[at] + list(pos) for at, pos in zip(u.atoms.names, u.atoms.positions)]
For example, with the test file PDB that is included with the MDAnalysisTests package:
import MDAnalysis as mda
from MDAnalysisTests.datafiles import PDB
u = mda.Universe(PDB)
names_positions = [[at] + list(pos) for at, pos in zip(u.atoms.names, u.atoms.positions)]
# show the first three entries
print(names_positions[:3])
gives
[['N', 52.017, 43.56, 31.555], ['H1', 51.188, 44.112, 31.722], ['H2', 51.551, 42.828, 31.039]]
Learning more...
For a rapid introduction to MDAnalysis have a look at the Quickstart Guide, which explains most of these things in more detail. It also tells you how to select specific atoms and form new AtomGroups.
Then you can have a look at the rest of the User Guide.
Bonds are a bit more tricky (you can get them with u.atoms.bonds but if you want to use them you have to learn more about how MDAnalysis represents topologies — I'd suggest you start by asking on user mailing list, see participating in MDAnalysis because this is where MDAnalysis developers primarily answer questions.)
I'm relatively new to Yosys. I've been tinkering with it with some proprietary standard cell libraries and am trying to extract some QoR/PPA metrics, similar to those you can get from DC.
Minimum slack (including worst-case negative slack/WNS)
Max logic depth [0]
Cell area [1]
For [0], I know there's the ltp command, but it only reports topological paths per module. I tried flattening the design using flatten, but there still seems to be a hierarchy in the netlist. Where should I insert the flatten command to actually flatten the netlist?
For [1], I know you can get the number of cells in the netlist using the stat command, but this doesn't tell me the equivalent of DC's CellArea metric (since each cell has a different area). I could just build a library of cell areas for each cell type based on the cell library datasheet, but that's rather laborious.
Also, is it possible to specify a target clock rate for synthesis? I think for abc there was a -D flag for delay, but this sounds to me more like input delay rather than clock period.
Thanks!
-D passed to abc is indeed clock period, not input delay. When specified this should also cause abc to print slack information.
Have you tried stat -liberty file.lib to use a liberty file for cell areas? If this isn't calculating areas as expected (I didn't quite understand your issue) then please create a feature request on GitHub with the difference.
flatten should be run after hierarchy -top top_module_name to do hierarchical elaboration and set the top module.
While elm-make succeeds, I get the following error in the browser:
Cannot read property 'kids' of undefined
I assume it's because I have a circular dependency of signals:
model -> clicks -> model
Here is the relevant code:
model : Signal Model
model =
Signal.foldp update initialModel clicks
clicks : Signal Action
clicks =
let
clickPosition = Mouse.position
|> Signal.sampleOn Mouse.clicks
tuplesSignal = Signal.map3 (,,) clickPosition Window.dimensions model
in
...
It feels like model is implemented as a common practice in Elm, so I should challenge the clicks -> model dependency.
Here is some context:
I'm building a sliding puzzle game using canvas:
When user clicks a tile that can move, it should move. Otherwise, the click should be ignored.
clicks will produce the following actions: Left, Right, Up, Down
For example, if user clicks on tiles 12, 11, 8, 15 (in this order), clicks should be: Down -> Right -> Up
The problem is, that in order to calculate which tile was clicked, I need to know the board dimensions (e.g. 4 rows and 4 columns in the picture above). But, board dimensions are stored in the model (imagine user interface that allows users to change board dimensions).
How do I get out of this circular dependency?
In this case I think you should go more low-level in what you call an input, and accept click positions as inputs. Then you can compose an update function in your Signal.foldp out of two others:
The first turns the clicks and model into a Maybe Direction (assuming the Left, Right, Up, Down are constructors of type Direction)
The second function that takes a Direction value and the model to calculate the new model. You can use Maybe.map and Maybe.withDefault to handle the Maybe part of the result of the first function.
Separating these two parts, even though you produce and consume Direction immediately, makes your system more self-documenting and shows the conceptual split between the raw input and the restricted "actual" inputs.
P.S. There are conceivable extensions to the Elm language that would allow you to more easily write this input preprocessing in signal-land. But such extensions would make the signal part of the language so much more powerful that it's unclear if it would make "the right way" to structure programs harder to discover.