Design and fabrication of auxetic PCL nanofiber membranes for biomedical applications

The main objective of this study was to fabricate poly (ε-caprolactone) (PCL)-based auxetic nanofiber membranes and characterize them for their mechanical and physicochemical properties. As a first step, the PCL nanofibers were fabricated by electrospinning with two different thicknesses of 40 μm (called PCL thin membrane) and 180 μm (called PCL thick membrane). In the second step, they were tailored into auxetic patterns using femtosecond laser cut technique. The physicochemical and mechanical properties of the auxetic nanofiber membranes were studied and compared with the conventional electrospun PCL nanofibers (non-auxetic nanofiber membranes) as a control. The results showed that there were no significant changes observed among them in terms of their chemical functionality and thermal property. However, there was a notable difference observed in the mechanical properties. For instance, the thin auxetic nanofiber membrane showed the magnitude of elongation almost ten times higher than the control, which clearly demonstrates the high flexibility of auxetic nanofiber membranes. This is because that the auxetic nanofiber membranes have lesser rigidity than the control nanofibers under the same load which could be due to the rotational motion of the auxetic structures. The major finding of this study is that the auxetic PCL nanofiber membranes are highly flexible (10-fold higher elongation capacity than the conventional PCL nanofibers) and have tunable mechanical properties. Therefore, the auxetic PCL nanofiber membranes may serve as a potent material in various biomedical applications, in particular, tissue engineering where scaffolds with mechanical cues play a major role. © 201

Reducing Context-Bounded Concurrent Reachability to Sequential Reachability

We give a translation from concurrent programs to sequential programs that reduces the context-bounded reachability problem in the concurrent program to a reachability problem in the sequential one. The translation has two salient features: (a) the sequential program tracks, at any time, the local state of only one thread (though it does track multiple copies of shared variables), and (b) all reachable states of the sequential program correspond to reachable states of the concurrent program. We also implement our transformation in the setting of concurrent recursive programs with finite data domains, and show that the resulting sequential program can be model-checked efficiently using existing recursive sequential program reachability tools

Zing: Exploiting program structure for model checking concurrent software

Abstract. Model checking is a technique for finding bugs in systems by systematically exploring their state spaces. We wish to extract sound models from concurrent programs automatically and check the behaviors of these models systematically. The zing project is an effort to build a flexible infrastructure to represent and model check abstractions of large concurrent software. To support automatic extraction of models from programs written in common programming languages, zing’s modeling language supports three facilities present in modern programming languages: (1) procedure calls with a call-stack, (2) objects with dynamic allocation, and (3) processes with dynamic creation, using both shared memory and message passing for communication. We believe that these three facilities capture the essence of model checking modern concurrent software. Building a scalable model-checker for such an expressive modeling language is a huge challenge. zing’s modular architecture provides a clear separation between the expressive semantics of the modeling language, and a simple view of zing programs as labeled transition systems. This separation has allowed us to decouple the design of efficient model checking algorithms from the complexity of supporting rich constructs in the modeling language. zing’s model checking algorithms have been designed to exploit existing structural abstractions in concurrent programs such as processes and procedure calls. We present two such novel techniques in the paper: (1) compositional checking of zing models for message-passing programs using a conformance theory inspired by work in the process algebra community, and (2) a new summarization algorithm, which enables zing to reuse work at procedure boundaries by extending interprocedural dataflow analysis algorithms from the compiler community to analyze concurrent programs.