Articles

FigureWCP Test c3d - Mathematics


FigureWCP Test c3d - Mathematics

Autodesk Grading Optimization for Civil 3D 2022

Once optimization begins, the real-time problem solving can be observed. Using several visualization themes for the surface, or by watching the trends of the convergence Descriptions, you can stop and change designs or let it run until a desired grading solution is found. If a solution is not possible, a best approximation is provided within your constraint requirements.

Grading Optimization is based on deterministic algorithms that will try to satisfy all of your design constraints on a surface.

Mass grading requires detailed models, balanced sites, and forward-thinking engineers and contractors. This session will look at a couple of mass grading sites and some best practices in creating, editing, and managing your models. From our model, we'll extract actionable data for projects at the bid and construction stages. We'll also look at best practices for machine control models and discuss some pitfalls to avoid.

A new extension for Civil 3D 2022 is Grading Optimization for Civil 3D. Grading Optimization uses new Grading objects provided to you in the Civil 3D tool palette.

-Increasing your productivity with intuitive design tools.
-Generating your Civil 3D design surfaces, profiles, assemblies, corridors, and pipe profiles with a simple mouse click.


Plotz PH (1982) Studies of immune complexes. Arthritis Rheum 25:1151–1155

Lambert PH, Dixon FJ, Zubler RH, Agnello V, Cambiaso C, Casali P, Clarke J, Cowdery JS, McDuffie FC, Hay FC, MacLennan ICM, Masson P, Müller-Eberhard HJ, Penttinen K, Smith M, Tappeiner G, Theofilopoulos AN, Verroust P (1978) A WHO collaborative study for the evaluation of eighteen methods for detecting immune complexes in serum. Clin Lab Immunol 1:1–15

McDougal JS, Hubbard M, Strobel PL, McDuffie FC (1982) Comparison of five assays for immune complexes in the rheumatic diseases. J Lab Clin Med 100:705–719

McDougal JS, Hubbart M, McDuffie FC, Strobel PL, Smith SJ, Bass N, Goldman JA, Hartman S, Myerson G, Miller S, Morales R, Wilson CH Jr (1982) Comparison of five assays for immune complexes in the rheumatic diseases. Arthritis Rheum 25:1156–1166

Brown EJ, Frank MM (1981) Complement activation. Immunol Today 2(7):129–134

Müller-Eberhard HJ, Schreiber RD (1980) Alternative pathway of complement. Adv Immunol 28:1–53

Buchanan WW, Tuymell P (1983) Traditional assessments of articular diseases. In: Clinics of rheumatic diseases. Saunders, Philadelphia, Pa, PP 9, 515

Brandslund I, Siersted HC, Svehag SE, Teisner B (1981) Double-decker rocket immunoelectrophoresis for direct quantitation of complement C3 split products with C3d specificities in plasma. J Immunol Methods 44:63–71

Krauledat PB, Krapf FE, Baudner S, Linhard H, Kalden JR (1983) Measurement of classical and alternative complement activation may represent the humoral immune status of patients with different rheumatic diseases. Clin Rheumatol 2:103–104

Perrin LH, Lambert PH, Miescher PA (1975) Complement breakdown products in plasma from patients with systemic lupus erythematosus and patients with membranoproliferative or other glomerulonephritis. J Clin Invest 56:165–176

Zubler RH, Lange G, Lambert PH, Miescher PA (1976) Detection of immune complexes in unheated sera by a modified 125 J-Clq binding test. J Immunol 116:232–235

Haupt H, Heimburger N (1972) Humanserumproteine mit hoher Affinität zu Carboxymethylcellulose, I. Hoppe Seylers Z Physiol Chem 353:1125–1132

Krapf F, Renger D, Schedel I, Leiendecker K, Leyssens H, Deicher H (1982) A PEG-precipitation laser nephelometer technique for detection and characterization of circulating immune complexes in human sera. J Immunol Methods 54:107–117

Kapmeyer W, Gronski P, Hofstaetter T (1980) Messung von Immunkomplexen definierter Zusammensetzung mit dem Laser Nephelometer. Bulletin SSCC/SGKC 21:124–127

Kruskal WH (1952) A non parametric test for the several sample problem. Am Math Stat 23:525–540

Krapf F, Renger D, Fricke M, Kemper A, Schedel I, Deicher H (1982) Nachweis von zirkulierenden Immunkomplexen bei Mammakarzinom und malignem Melanom mit drei verschiedenen Methoden. Tumor Diagn Ther 3:219–225

Geissler M, Krapf F, Liman W, Deicher H (1982) Klinische Korrelation einer neuen Nachweismethode für zirkulierende Immunkomplexe bei der chronischen Polyarthritis. Z Rheumatol 4114:17

Bourke B, Moss I, Maini RN (1980) A quantitative measurement of complement (C3) activation in SLE and rheumatoid arthritis. Ann Rheum Dis 39:602–603

Perrin LH, Nydegger UE, Zubler RH, Lambert PH, Miescher PA (1977) Correlation between levels of breakdown products of C3, C4, and properdin factor B in synovial fluids from patients with rheumatoid arthritis. Arthritis Rheum 20:647–652

Mallya RK, Vergani D, Tee DEH, Bevis L, deBeer FC, Berry H, Hamilton EDB, Mace BEW, Pepys MB (1982) Correlation in rheumatoid arthritis of concentrations of plasma C3d, serum rheumatoid factor, immune complexes and C-reactive protein with each other and with clinical features of disease activity. Clin Exp Immunol 48:747–753

Swaak AJG, Hannema A, Vogelaar C, Boom FA, Es L van, Aalst R van, Statius van Eps LW (1982) Determination of the half-life of C3 in patients and its relation to the presence of C3-breakdown products and/or circulating immune complexes. Rheumatol Int 2:161–166


Express yourself using expressions in Civil 3D

0

Expressions in Autodesk Civil 3D have been around since the beginning of time……Civil 3D time! However, I don’t think people utilize expressions to their full capabilities, or even at all. I’ve heard of some pretty cool ways people are using expressions to label and analyze their models in Civil 3D and thought I’d share a few.

This article helps walk through setting up a couple Civil 3D expressions, starting with simple mathematical formulas to more advanced analysis expressions.

About Expressions

Civil 3D expressions are stored in the Settings tree, within the label style type folders. They are not available for label style types that do not have relevant properties, such as Note label styles. But for the most part, they are available in every type of label such as surface, alignment, profile, etc.

You insert expressions into label styles using the Text Component Editor when you are editing a label style text component.


Expressions make use of the same properties that you can add to label styles, such as Point Elevation, Northing, and Easting. By using expressions, you can set up separate mathematical formulas using the existing properties. There are two main portions to creating an expression. You will find these in the New Expression dialog box.

Insert Property

Inserts a property into the expression. Click the icon to display a list of properties relevant to the expression type. Select a property to insert it into the expression. These are the same properties that are available for label styles.

Properties are inserted inside brackets. Do not add operators or functions within these brackets.

Insert Function

Inserts a function into the expression. Such as IF(test,true_val,false_val), ROUNDUP(x,y), etc

For example, you could subtract a value from a point elevation, and display that number alongside the actual elevation in a point label. Let’s create that example.

Creating a Simple Expression

For this first expression, we will keep it very simple. In this example, we will create a label for a parking lot, using a spot elevation we will label the LIP of gutter, but within the same label, have it label the TBC (Top Back of Curb) with an elevation difference of 0.33’ (or 0.17’ for shed curb). Let’s get started:

1) Go to your SETTING tab, expand surface, label styles and Spot Elevation.
2) Right click on Expressions and select NEW

3) Name your expression “Capture Curb – LIP / TBC”.
4) Give your expression a description. I like using descriptions here so that end users, other than the expression creator, can understand the intention of the expression.
5) At the bottom of the New expression dialog box, change the Format result as to ELEVATION
6) In the Expression Editor box, select SURFACE ELEVATION from the INSERT PROPERTY drop down.
7) After you insert that property, type in (or select from the dialog box) +0.33.
8) Select OK to accept and save your expression.

9) Let’s now add this to a Spot Elevation label style, and label our surface. Create a new Spot Elevation style called “Elev Label – Capture Curb + LIP”
10) In the label style, we will have two text components, one for our main surface spot we wish to label (LIP) and the other that will reference our expression (TBC)
11) In the Text Component Editor Properties, you will now see your expression, add that to the new component.
12) Properly compose your label as shown in FIG05.


13) Now use the ADD LABELS dialog box to add the newly created label to a few spots. You can now see that by labeling the one spot, the mathematical equation we setup in the expression will then add the 0.33’ we specified.


Now let’s try some more advanced expressions!

Expression for Cut / Fill Text

Another useful example for expressions is to use them to aid in labeling cut vs. fill labels in a volume surface. For example, you may want to display your CUT in red, and you FILL in blue. To do so, we will setup a couple quick expressions.

1) First, ensure you have a VOLUME surface created. This goes without explain, but thought I would mention it anyway!
2) Create two expressions, one for the Cut Text height and one for the Fill Text height.
3) Name this first expression Cut-Text. Use this as the expression: IF(<0,0.10/12,0.00000001)
4) Name this second expression Fill-Text. Use this as the expression: IF(<=0,0.12/12,0.00000001)

What we are doing here, is creating a super small text that will NOT show up once we place our labels. These expressions are slightly different, we won’t use these in our label composer, but we will use these to adjust the text height and differentiate Cut v. Fill.

5) Create a label style that has 2 components, Cut and Fill text. These components reference the Surface Elevation, but in the text height property, you will set the corresponding expression (Cut/Fill).
6) Change the CUT component color to RED.
7) Change the FILL component to BLUE.

8) Test this out by using your new label style to label a surface!!


Expression for Pipe Calculations

Want to have dynamic flow rates or velocities for your gravity networks? One way to do so is to create an expression utilizing the Manning’s equation to get the flow rate (Q) and the flow velocity (V)

Once we have completed the expression for Q, we can create the expression for V (or other calcs): Q/(pi*(/2)^2)

Time in Pipe could be another necessary calculation: <2D Length – To Inside Edges>/Velocity/60

Misc. Expressions

Here are a few others I’ve used in Civil 3D.

Truncate your elevations. An example of this is displaying an elevation of 132.67 as 32.67:

Point Slope Arrow – Arrow always pointing downhill

  • IF( <= 0, 0, pi)
  • This expression gets applied to the Rotation Angle of the direction arrow component.


Pipe True Slope

Length in Meter – Display both (any object)

Slope Distance AND Horizontal Distance in a label (Use on lines, polylines, figures and feature lines)

There are many…MANY expressions you can create within Civil 3D. Hopefully this helps get the brain going and thinking about how you can further increase your productivity by testing the limits of label styles and expression composition.

As always, I am interested to hear what you think and see how we can improve upon this topic. If you have some crazy cool Civil 3d expressions, I’d love to see them in action, shoot me an email or connect with me on LinkedIn.


Compiling ELFE

To build ELFE, just use make . On a Raspberry Pi, a make -j3 should run in about 10 minutes if you start from scratch. On a version 2, it's about one minute. On a modern PC, it's may be as low as 3 to 5 seconds. If make works (and it should), then use sudo make install to install the target. In summary:

The default location is /usr/local/bin/elfe , but you can install in /opt/local/ for example by building with make PREFIX=/opt/local/ . Don't forget the trailing / .

If you are paranoid, you can, from the top-level, run make check to validate that your installation is running correctly. It is possible for a test named 04-basic-operators-in-function to fail on some machines, because C arithmetic for << and >> operators is not portable. I will fix that one day. If other tests fail, look into file tests/failures-default.out for details of what went wrong.

Running an ELFE server

To start an ELFE server on a node, simply run elfe -l .

By default, ELFE listens on port 1205. You can change that by using the -listen option:

Now, let's try a first test program. On boss , edit a file called hello.elfe , and write into it the following code:

Replace "pi" with the actual Internet name of your target machine. Then execute that little program with:

Normally, the console output on pi should now look like this:

What happens behind the scene is that ELFE on boss sent the program given as an argument to tell to the machine named pi (which must be running an ELFE in listen mode, i.e. have elfe -l running). Then, that program executes on the slave. The tell command is totally asynchronous, it does not wait for completion on the target.

If this example does not work as intended, and if no obvious error appears on the console of either system, you can debug things by adding -tremote ( -t stands for "trace", and enables specific debug traces, in that case any code conditioned by IFTRACE(remote) in the Elfe source code).

The magic behind the scene

There are three key functions to send programs across nodes:

  • tell sends a program asynchronously
  • ask sends a program synchronously and waits for the result
  • invoke sends a program and opens a bi-directional channel. The node can then use reply to execute code back in the caller's program

ELFE sends not just the program segments you give it, but also the necessary data, notably the symbols required for correct evaluation. This is the reason why things appear to work as a single program.


FigureWCP Test c3d - Mathematics

Extensible Language for Everyday (and the Internet of Things)

ELFE is a very simple and small programming language specifcally designed for everyday programming, notably for the Internet of Things.

While ELFE is a general-purpose programming language, it is designed to facilitate the configuration and control of swarms of small devices such as sensors or actuators. It can also be used as a powerful, remotely-accessible extension language for larger applications. The examples below will focus on this particular domain. For more information about the language, please read the [reference manual] (https://github.com/c3d/elfe/blob/master/doc/ELFE_Reference_Manual.pdf)

ELFE used to be called ELIoT (Extensible Language for the Internet of Things), but Legrand complained about it, having a trademark on the name. ELFE is for more than just IoT, so we might as well acknowlege that in the name also -)

Example: Measuring temperature

Consider a sensor named sensor.corp.net running ELFE and featuring a temperature measurement through a temperature function.

ELFE lets you evaluate programs on this sensor remotely to do all kinds of interesting temperature measurements. By deferring computations to the sensor, we minimize network traffic and energy consumption. Examples similar to the ones below can be found in the demo directory.

Simple temperature measurement (polling)

To measure the temperature on a remote node called "sensor.corp.net", use the following code:

The -> rewrite operator reads "transforms into" and is used in ELFE to define variables, functions, macros, and so on. Look into builtins.elfe for examples of its use.

The ask function sends a program on a remote node, waits for its completion, and returns the result. So each time we call temperature_on_sensor , we send a program containing temperature on the remote node called sensor.corp.net , and wait for the measured value.

Reporting sudden changes in temperatures

An application may be interested in sudden changes in temperatures, e.g. if the sensor suddenly warms up. With ELFE, without changing anything to the temperature API, you can check the temperature every second and report if it changed by more than 1 degree since last time it was measured with the following program:

The invoke function sends a program to the remote node and opens a bi-directional connexion, which allows the sensor to reply when it feels it has useful data to report. In that case, the sensor replies with a call to temperature_changed , sending back the old and new temperature, and the controlling node can display a message using writeln .

Reporting changes in temperatures since last report

Another application may be interested in how temperature changes over time, even if the change is gradual. In that case, you want to report temperature if it changes by more than one degree since last time it was reported (instead of measured). You can do that with a slight variation in the code above, so that you update last_temperature only after having transmitted the new value, not after having measured it:

In ELFE, indentation is significant, and defined "blocks" of code. Other ways to delimit a block of code include brackets < code >(which we used in the first example, where we passed the < temperature >block to the remote sensor, as well as parentheses (code) or square brackets [code] . The latter two are used for expressions.

Computing average, min and max temperatures

Again using the same sensor, and again without any code or API change on the sensor, you can also have it compute min, max and average temperatures from samples taken every 2.5 seconds:

This program looks and behaves like a single program, but will actually be executing on three different machines that may possibly located hundreds of miles from one another.

A very powerful, yet simple API

With these examples, we have demonstrated that using ELFE, we can answer queries from applications that have very different requirements. An application will get exactly the data it needs, when it needs it, minimizing network traffic and optimizing energy utilization.

Yet the API on the sensors and on the controlling computer is extremely simple. On the sensor, we only have a single function returning the temperature. And on the controlling computer, we have a single language that deals with data collection, timing, exchange between nodes, computations, and more.

How do we measure the temperature?

It is very simple to add your own functions to ELFE, and to call any C or C++ function of your choosing. The temperature function is implemented in a file called temperature.tbl. It looks like this:

In that code, we read core temperature data as reported by Linux on Raspberry Pi by reading the system file /sys/class/thermal/thermal_zone0/temp . This file returns values in 1/1000th of a Celsius, so we multiply the value we read by 0.001 to get the actual temperature.

To add the temperature module to ELFE, we just need to add it to the list of modules in the Makefile:

This will build at least temperature.tbl . That file contains the interface between ELFE and your code. In simple cases like our temperature measurement, it may be sufficient. However, if you have files called temperature.h or temperature.cpp , they will be integrated in your temperature module. This lets you add supporting classes or functions.

The tell , ask , invoke and reply words are implemented in the module called remote , which consists of remote.tbl, remote.h and remote.cpp. This may not be the easiest module to study, however. You may find io.tbl easier to understand.

To build ELFE, just use make . On a Raspberry Pi, a make -j3 should run in about 10 minutes if you start from scratch. On a version 2, it's about one minute. On a modern PC, it's may be as low as 3 to 5 seconds. If make works (and it should), then use sudo make install to install the target. In summary:

The default location is /usr/local/bin/elfe , but you can install in /opt/local/ for example by building with make PREFIX=/opt/local/ . Don't forget the trailing / .

If you are paranoid, you can, from the top-level, run make check to validate that your installation is running correctly. It is possible for a test named 04-basic-operators-in-function to fail on some machines, because C arithmetic for << and >> operators is not portable. I will fix that one day. If other tests fail, look into file tests/failures-default.out for details of what went wrong.

To start an ELFE server on a node, simply run elfe -l .

By default, ELFE listens on port 1205. You can change that by using the -listen option:

Now, let's try a first test program. On boss , edit a file called hello.elfe , and write into it the following code:

Replace "pi" with the actual Internet name of your target machine. Then execute that little program with:

Normally, the console output on pi should now look like this:

What happens behind the scene is that ELFE on boss sent the program given as an argument to tell to the machine named pi (which must be running an ELFE in listen mode, i.e. have elfe -l running). Then, that program executes on the slave. The tell command is totally asynchronous, it does not wait for completion on the target.

If this example does not work as intended, and if no obvious error appears on the console of either system, you can debug things by adding -tremote ( -t stands for "trace", and enables specific debug traces, in that case any code conditioned by IFTRACE(remote) in the ELFE source code).

The magic behind the scene

There are three key functions to send programs across nodes:

  • tell sends a program asynchronously
  • ask sends a program synchronously and waits for the result
  • invoke sends a program and opens a bi-directional channel. The node can then use reply to execute code back in the caller's program

ELFE sends not just the program segments you give it, but also the necessary data, notably the symbols required for correct evaluation. This is the reason why things appear to work as a single program.

Basics of ELFE syntax and semantics

ELFE derives from XLR. It is a specially trimmed-down version that does not require LLVM and can work in full interpreted mode, making it easier to compile and use, but also safer, since you cannot call arbitrary C functions.

Semantics: One operator to rule them all

ELFE has one fundamental operator, -> , the "rewrite operator", which reads as transforms into. It is used to declare variables:

It can be used to declare functions:

The rewrite operator can be used to declare other operators:

But it is a more general tool than the operator overloading found in most other languages, in particular since it allows you to easily overload combinations of operators, or special cases:

Rewrites are considered in program order, and pattern matching finds the first one that applies. For example, factorial is defined as follows:

Many basic program structures are defined that way in builtins.elfe. For example, if-then-else and infinite loops are defined as follows:

Syntax: Look, Ma, no keywords!

ELFE has no keywords. Instead, the syntax relies on a rather simple recursive descent parser.

THe parser generates a parse tree made of 8 node types. The first four node types are leaf nodes:

  • Integer is for integer numbers such as 2 or 16#FFFF_FFFF .
  • Real is for real numbers such as 2.5 or 2#1.001_001_001#e-3
  • Text is for text values such as "Hello" or 'World' . Text can be encoded using UTF-8
  • Name is for names and symbols such as ABC or **

The last four node types are inner nodes:

  • Infix are nodes where a named operator separates the operands, e.g. A+B or A and B .
  • Prefix are nodes where the operator precedes the operand, e.g. +X or sin X . By default, functions are prefix.
  • Postfix are nodes where the operator follows the operand, e.g. 3% or 5km .
  • Block are nodes with only one child surrounded by delimiters, such as (A) , [A] or .

Of note, the line separator is an infix that separates statements, much like the semi-colon . The comma , infix is traditionally used to build lists or to separate the argument of functions. Indentation forms a special kind of block.

For example, the following code:

parses as a prefix tell , with an infix , as its right argument. On the left of the , there is the text "foo" . On the right, there is an indentation block with a child that is an infix line separator. On the left of the line separator is the if statement. On the right is the name world .

This parser is dynamically configurable, with the default priorities being defined by the elfe.syntax file.

Parse trees are the fundamendal data structure in ELFE. Any data or program can be represented as a parse tree.

ELFE as a functional language

ELFE can be seen as a functional language, where functions are first-class entities, i.e. you can manipulate them, pass them around, etc:

Most human being parse this as meaning write (sin(X),cos(Y)) , i.e. we call write with two values resulting from evaluating sin X and cos Y . This is not entirely logical. If write takes comma-separated arguments, why wouldn't sin also take comma-separated arguments? In other words, why doesn't this parse as write(sin(X, cos(Y)) ?

This shows that humans have a notion of expressions vs. statements. Expressions such as sin X have higher priority than commas and require parentheses if you want multiple arguments. By contrast, statements such as write have lower priority, and will take comma-separated argument lists. An indent or < >block begins a statement, whereas parentheses () or square brackets [] begin an expression.

There are rare cases where the default rule will not achieve the desired objective, and you will need additional parentheses.

Subtlety #2: infix vs. prefix

Another special rule is that ELFE will use the presence of space on only one side of an operator to disambiguate between an infix or a prefix. For example:

Subtlety #3: Delayed evaluation

When you pass an argument to a function, evaluation happens only when necessary. Deferred evaluation may happen multiple times, which is necessary in many cases, but awful for performance if you do it by mistake.

Consider the following definition of every :

In that case, we want the Body to be evaluated every iteration, since this is typically an operation that we want to execute at each loop. Is the same true for Duration ?

One way to force evaluation is to give a type to the argument. If you want to force early evaluation of the argument, and to check that it is a real value, you can do it as follows:

Subtlelty #4: Closures and remote transport

Like many functional languages, ELFE ensures that the value of variables is preserved for the evaluation of a given body. Consider for example:

In that case, adder 3 will bind X to value 3 , but then the returned value outlives the scope where X was declared. However, X is referred to in the code. So the returned value is a closure which integrates the binding X->3 .

At this point, such closures cannot be sent across a tell , ask , invoke or reply . Make sure data that is sent over to a remote node has been evaluated before being sent.


About the Pipe To Pipe Match Rule

By:

This rule governs how a pipe elevation is determined in a pipe network that contains only pipes (no structures), and or when a pipe is inserted onto an existing pipe to break the pipe.

This rule applies only during the following conditions:

  • Creating a pipe network that has pipes only (no structures)
  • Breaking into an existing pipe with another pipe
  • Connecting a pipe to a null structure (pipe to pipe connection with no structure)
  • Connecting a pipe to an existing pipe end

This rule manages conditions so that only continuous runs of pipe are created as typically expected. In pipe networks where the pipe size is constant, pipes connected to other pipes must to match end to end. In pipe networks where pipe sizes change, the point where pipes match may change, depending on the type of system. For example, in pressure systems, it may be typical to match the pipe centerline. In gravity systems, it may be typical to match the crowns of the pipes.

This rule also incorporates a drop value for cases where a pipe-to-pipe connection requires a drop amount.


Computation and Data-Driven Discovery (C3D): Components

Synchrotron light sources produce intense photon beams ranging in energy from the infrared to the hard x-ray end of the electromagnetic spectrum. NSLS-II is a new state-of-the-art, medium-energy electron storage ring designed to deliver world-leading intensity and brightness, and will produce x-rays more than 10,000 times brighter than the current NSLS at Brookhaven Lab. The photon beams at NSLS-II will be used by thousands of researchers annually in many important scientific and technology areas such as condensed matter physics, materials science, environmental science, chemistry, energy science, communications, semiconductors, catalysis, nanoscience, geo-science, biology, and membrane science. When NSLS-II begins operations in 2015, the superlative character and combination of capabilities will also have broad impact on a number of scientific initiatives, including the National Institutes of Health’s structural genomics initiative, DOE’s Genomics:GTL initiative, and the federal nanoscience initiative.

The improved brightness at NSLS-II together with the development of new detector technology requires new computing approaches to experiment control, data management, data analysis workflow, and metadata handling with high performance on data storage and retrieval, as well as visualization. These types of systems are being incorporated to provide high levels of precision control of the accelerator used to produce the beams and the beamlines at which light is used to collect experimental data. Computational architectures installed at NSLS-II experimental end stations will enable nearly real-time (in-situ) streaming analysis to reduce raw data, perform data transformations, reconstruction, analysis, and visualization. These systems will assure data quality control and inform the investigators to guide the experiment progression. To reduce the time required for configuring these tasks, the NSLS-II team has developed a prototype workflow system to help users easily define data-processing tasks via a simple web interface, to automate task management, to ensure task inter-dependency, and accelerate each task with state-of-the-art parallel computing paradigms


Computation and Data-Driven Discovery (C3D) Projects

New beamlines at the National Synchrotron Light Source II (NSLS-II) with high data payloads are in need of data analysis tools and streaming data analysis pipelines. High-throughput science experiments generate multidimensional data at a high rate.

The XPCS (X-ray Photon Correlation Spectroscopy) and XSVS (X-ray Speckle Visibility Spectroscopy) are two techniques used to study structural dynamics of various equilibrium and non-equilibrium processes occurring in condensed matter systems. Coherent Hard X-ray (CHX) and Coherent Soft X-ray (CSX-1) beamlines collect long series of images to study the dynamics of materials using XPCS and XSVS. This project is focused on developing an excellent set of data analysis tools and streaming data analysis pipelines to address the needs of these beamlines.

Already developed data analysis tools for studying the structural dynamics of materials are now available in github Scikit-beam repository (Scikit-beam project).

Scikit-beam

Scikit-beam is a python package originally being developed at the NSLS-II by the Data Acquisition, Management and Analysis (DAMA) group. This library is not only available for the beamlines of NSLS-II but also available for the broader scientific community. Now this is a multi-facilities effort, we have contributors from other Department of Energy (DOE) laboratories. The primary objective of Scikit-beam is to develop a comprehensive set of data analysis tools that minimize technique-specificity and, instead, maximize code re-usability. Our library supports a wide range of user expertise, from novice to developer. We also provide use case examples in Scikit-beam-examples for the tools included in Scikit-beam. They are in two formats: Jupyter (a.k.a Ipython notebooks) and python scripts. By providing both formats, users are able to learn to build analysis workflows using the tools included in Scikit-beam, and more advanced users can see, in detail, how to incorporate Scikit-beam into their own analysis scripts or programs.

Xray-vision

Visualization widgets and plotting tools for the data processing and analysis are available in the xray-vision repository.

Fig. 1. Manual Mask gui tool in xray-vision.

The image is an average over 5000 raw measurements with 1ms integration time (Left). The dark shadow of the beamstop, the dark columns in the scattering pattern and unwanted pixels are masked out using the manual mask gui tool (right) before analysis.

This figure represents 4 ring shaped region of interests (ROI’s) created using scikit-beam roi module. The ROI module contains software tools to generate ROI’s labeled arrays for simple shapes, such as, rectangles and concentric circles.

Figure 3. Multi_tau_auto_corr function in skbeam/correlation

Auto correlation function, g2(q, t) (red circles) calculated for 5000 masked images (Figure 1) using multi_tau_auto_corr function in skbeam. These g2(q,t) plotted as a function of time delay, t from the XPCS analysis over four q rings (Figure 2) of pixels at q=2.48x10-3Å-1, q=2.58x10-3Å-1, q=2.79x10-3Å-1 and q=2.89x10-3Å-1 (red circles) for masked image data. The experimental g2(q, t) plots (red circles) are fitted using auto_corr_scat_factor function in skbeam (blue line) for the XPCS analysis. These plots represent results form 5000 images. Streaming tools can be used to generate these results while the data is being collected. In this way, data quality can be determined on the fly, and change the scan strategy without interrupting the analysis, if needed.

Project Team

Principal Investigator

Research Associate

Collaborators

  • Eric Dill, Thomas Caswell, Annie Heroux - (DAMA, NSLS-II)
  • Andrei Fluerasu, Yugang Zhang - (CHX beamline, NSLS-II)
  • Stuart Wilkins, Claudio Mazzoli, Andi Barbour - (CSX-1 beamline, NSLS-II)

About BrookhavenLabCS

CSI research and capabilities continue to expand the state of the art in high-performance computing, applied mathematics, data science, and Quantum Information Science to propel advances at the frontiers of science here at Brookhaven National Laboratory, throughout the nation, and across the world.


Part 1

I am sure we have all had to calculate an area of a pond, footprint, or some other irregular shape in AutoCAD. What about those times when we need to convert to acres, simple – right? We just get out our calculator or use the onscreen calculator and do the math. Let’s let AutoCAD do that for us. We are now going to locate or create a closed object or polyline in a drawing and place a leader with mtext on an object and use a field to label the area (in acres) of the object. Let’s first drawing an irregular shape on our drawing. Next type the mleader command and place a leader pointing to the object as shown in Figure 2.

Figure 2: Object – Mtext – Label

Notice how we do not have anything after the “=” sign for the area. Right click and highlight (red box) where you want the number to be in your mtext and select insert field as shown in Figure 3.

Figure 3: Right click-Insert Field

You now need to change the field category to Objects (1) and then hit the Object type button (2) and you will be sent back to out to the AutoCAD screen to select the object.

Figure 4: Select the Object

Select the outer bold line (boundary) in your drawing. The field selection window will pop up. Select Area then Decimal. But wait, we want acres and this is in standard units 1-1 which would be square feet. We are assuming that the coordinate system is setup to decimal units or 1-1. Therefore the value displayed in the field will be in square feet and not acres. We just need to additional format to the field. Checking the coordinate system is very important for any type of calculation. Make sure you are in the correct coordinate system and your drawing units are correct.

Figure 5: Field selections

Select the additional format button as shown above in Figure 5 above and another dialog box will pop up and you can add some custom formatting. We need to convert the value to Acres and we also would like to add a suffix as shown in Figure 5 .

  • Step 1 you are going to divide the value by 43,560 which is how many square feet are in an acre.
  • Step 2 you will add a Suffix, in this case we are adding the word ACRES.

Figure 6: Additional Format


You now have linked a field with additional format to an object in AutoCAD. If you revise the boundary the field will automatically update with the new area shown in Acres. If you break the link between the object and the field, simply right click and reselect the object following the steps above. Your final output should look just like Figure 6 below. Don’t forget to change the precision to your desired output, you can change this in the additional format window as shown in Figure 6.

Figure 7: Area Calculation Shown


What the Direct Results Mean

A positive direct Coombs test shows you have antibodies attached to your red blood cells, but it doesn't necessarily tell you which ones or why.

Regardless of the result of a direct Coombs test, you may need other tests to find the right diagnosis and treatment.

Sources

MSD Manual Professional Version: "Overview of Hemolytic Anemia."

LabTestsOnline.org: "RBC Antibody Screen," "Direct Antiglobulin Test."

Institute for Transfusion Medicine, Transfusion Medicine Updates: "Indirect and Direct Antiglobulin (Coombs) Testing and the Crossmatch."

Deane, L. Blood Groups and Red Cell Antigens, National Center for Biotechnology Information, 2005.

Medscape: "Direct Antiglobulin Testing," "Transfusion Reactions Workup."

American Journal of Hematology: "The direct antiglobulin test: A critical step in the evaluation of hemolysis."

Stanford Medicine, Newborn Nursery: "The Coombs' Test."

Johns Hopkins Lupus Center: "Coombs' Test."

University of Rochester Medical Center: "Blood Type and Crossmatch."

Archives of Pathology & Laboratory Medicine Online: "The Direct Antiglobulin Test: Indications, Interpretations, and Pitfalls."


Watch the video: How to create a WordPress LMS Website with Eduma theme - eduma wordpress theme tutorial (October 2021).