text:
• We present the results of a search for dark matter WIMPs in the mass range below 20 GeV/c^2 using a target of low-radioactivity argon. The data were obtained using the DarkSide-50 apparatus at Laboratori Nazionali del Gran Sasso (LNGS). The analysis is based on the ionization signal, for which the DarkSide-50 time projection chamber is fully efficient at 0.1 keVee. The observed rate in the detector at 0.5 keVee is about 1.5 events/keVee/kg/day and is almost entirely accounted for by known background sources. We obtain a 90% C.L. exclusion limit above 1.8 GeV/c^2 for the spin-independent cross section of dark matter WIMPs on nucleons, extending the exclusion region for dark matter below previous limits in the range 1.8-6 GeV/c^2.
• We present new constraints on sub-GeV dark matter particles scattering off electrons in argon based on an analysis of ionization signal data from the DarkSide-50 detector.
• The DarkSide-50 direct-detection dark matter experiment is a dual-phase argon time projection chamber operating at Laboratori Nazionali del Gran Sasso. This paper reports on the blind analysis and spin-independent dark matter-nucleon coupling results from a 532.4 live-days exposure, using a target of low-radioactivity argon extracted from underground sources. The background-free result in the dark matter selection box gave no evidence for dark matter. The present blind analysis sets a 90% C.L. upper limit on the dark matter-nucleon spin-independent cross section of 1.1E-44 cm^2 (3.8E-44 cm^2, 3.4E-43 cm^2) for a WIMP mass of 100 GeV/c^2 (1 TeV/c^2, 10 TeV/c^2).
• Electroluminescence pulse shape and electron diffusion in liquid argon measured in a dual-phase TPC(1802.01427)

Feb. 5, 2018 physics.ins-det
We report the measurement of the longitudinal diffusion constant in liquid argon with the DarkSide-50 dual-phase time projection chamber. The measurement is performed at drift electric fields of 100 V/cm, 150 V/cm, and 200 V/cm using high statistics $^{39}$Ar decays from atmospheric argon. We derive an expression to describe the pulse shape of the electroluminescence signal (S2) in dual-phase TPCs. The derived S2 pulse shape is fit to events from the uppermost portion of the TPC in order to characterize the radial dependence of the signal. The results are provided as inputs to the measurement of the longitudinal diffusion constant DL, which we find to be (4.12 $\pm$ 0.04) cm$^2$/s for a selection of 140keV electron recoil events in 200V/cm drift field and 2.8kV/cm extraction field. To study the systematics of our measurement we examine datasets of varying event energy, field strength, and detector volume yielding a weighted average value for the diffusion constant of (4.09 $\pm$ 0.09) cm$^2$ /s. The measured longitudinal diffusion constant is observed to have an energy dependence, and within the studied energy range the result is systematically lower than other results in the literature.
• CALIS - a CALibration Insertion System for the DarkSide-50 dark matter search experiment(1611.02750)

Sept. 27, 2017 physics.ins-det
This paper describes the design, fabrication, commissioning and use of a CALibration source Insertion System (CALIS) in the DarkSide-50 direct dark matter search experiment. CALIS deploys radioactive sources into the liquid scintillator veto to characterize the detector response and detection efficiency of the DarkSide-50 Liquid Argon Time Projection Chamber, and the surrounding 30 t organic liquid scintillator neutron veto. It was commissioned in September 2014 and has been used successfully in several gamma and neutron source campaigns since then. A description of the hardware and an excerpt of calibration analysis results are given below.
• Simulation of argon response and light detection in the DarkSide-50 dual phase TPC(1707.05630)

Sept. 26, 2017 hep-ex, physics.ins-det
A Geant4-based Monte Carlo package named G4DS has been developed to simulate the response of DarkSide-50, an experiment operating since 2013 at LNGS, designed to detect WIMP interactions in liquid argon. In the process of WIMP searches, DarkSide-50 has achieved two fundamental milestones: the rejection of electron recoil background with a power of ~10^7, using the pulse shape discrimination technique, and the measurement of the residual 39Ar contamination in underground argon, ~3 orders of magnitude lower with respect to atmospheric argon. These results rely on the accurate simulation of the detector response to the liquid argon scintillation, its ionization, and electron-ion recombination processes. This work provides a complete overview of the DarkSide Monte Carlo and of its performance, with a particular focus on PARIS, the custom-made liquid argon response model.
• We report on the cryogenic characterization of Red Green Blue - High Density (RGB-HD) SiPMs developed at Fondazione Bruno Kessler (FBK) as part of the DarkSide program of dark matter searches with liquid argon time projection chambers. A dedicated setup was used to measure the primary dark noise, the correlated noise, and the gain of the SiPMs at varying temperatures. A custom-made data acquisition system and analysis software were used to precisely characterize these parameters. We demonstrate that FBK RGB-HD SiPMs with low quenching resistance (RGB-HD-LR$_q$) can be operated from 40 K to 300 K with gains in the range $10^5$ to $10^6$ and noise rates on the order of a few Hz/mm$^2$.
• Building on the successful experience in operating the DarkSide-50 detector, the DarkSide Collaboration is going to construct DarkSide-20k, a direct WIMP search detector using a two-phase Liquid Argon Time Projection Chamber (LArTPC) with an active (fiducial) mass of 23 t (20 t). The DarkSide-20k LArTPC will be deployed within a shield/veto with a spherical Liquid Scintillator Veto (LSV) inside a cylindrical Water Cherenkov Veto (WCV). Operation of DarkSide-50 demonstrated a major reduction in the dominant $^{39}$Ar background when using argon extracted from an underground source, before applying pulse shape analysis. Data from DarkSide-50, in combination with MC simulation and analytical modeling, shows that a rejection factor for discrimination between electron and nuclear recoils of $\gt3\times10^9$ is achievable. This, along with the use of the veto system, is the key to unlocking the path to large LArTPC detector masses, while maintaining an "instrumental background-free" experiment, an experiment in which less than 0.1 events (other than $\nu$-induced nuclear recoils) is expected to occur within the WIMP search region during the planned exposure. DarkSide-20k will have ultra-low backgrounds than can be measured in situ. This will give sensitivity to WIMP-nucleon cross sections of $1.2\times10^{-47}$ cm$^2$ ($1.1\times10^{-46}$ cm$^2$) for WIMPs of $1$ TeV$/c^2$ ($10$ TeV$/c^2$) mass, to be achieved during a 5 yr run producing an exposure of 100 t yr free from any instrumental background. DarkSide-20k could then extend its operation to a decade, increasing the exposure to 200 t yr, reaching a sensitivity of $7.4\times10^{-48}$ cm$^2$ ($6.9\times10^{-47}$ cm$^2$) for WIMPs of $1$ TeV$/c^2$ ($10$ TeV$/c^2$) mass.
• Effect of Low Electric Fields on Alpha Scintillation Light Yield in Liquid Argon(1611.00241)

Nov. 4, 2016 nucl-ex, physics.ins-det
Measurements were made of scintillation light yield of alpha particles from the $^{222}$Rn decay chain within the DarkSide-50 liquid argon time projection chamber. The light yield was found to increase as the applied electric field increased, with alphas in a 200 V/cm electric field exhibiting a 2% increase in light yield compared to alphas in no field.
• The Electronics and Data Acquisition System for the DarkSide-50 Veto Detectors(1606.03316)

June 10, 2016 hep-ex, physics.ins-det
DarkSide-50 is a detector for dark matter candidates in the form of weakly interacting massive particles (WIMPs). It utilizes a liquid argon time projection chamber (LAr TPC) for the inner main detector. The TPC is surrounded by a liquid scintillator veto (LSV) and a water Cherenkov veto detector (WCV). The LSV and WCV, both instrumented with PMTs, act as the neutron and cosmogenic muon veto detectors for DarkSide-50. This paper describes the electronics and data acquisition system used for these two detectors.
• Results from the first use of low radioactivity argon in a dark matter search(1510.00702)

Liquid argon is a bright scintillator with potent particle identification properties, making it an attractive target for direct-detection dark matter searches. The DarkSide-50 dark matter search here reports the first WIMP search results obtained using a target of low-radioactivity argon. DarkSide-50 is a dark matter detector, using two-phase liquid argon time projection chamber, located at the Laboratori Nazionali del Gran Sasso. The underground argon is shown to contain Ar-39 at a level reduced by a factor (1.4 +- 0.2) x 10^3 relative to atmospheric argon. We report a background-free null result from (2616 +- 43) kg d of data, accumulated over 70.9 live-days. When combined with our previous search using an atmospheric argon, the 90 % C.L. upper limit on the WIMP-nucleon spin-independent cross section based on zero events found in the WIMP search regions, is 2.0 x 10^-44 cm^2 (8.6 x 10^-44 cm^2, 8.0 x 10^-43 cm^2) for a WIMP mass of 100 GeV/c^2 (1 TeV/c^2 , 10 TeV/c^2).
• Nuclear recoil events produced by neutron scatters form one of the most important classes of background in WIMP direct detection experiments, as they may produce nuclear recoils that look exactly like WIMP interactions. In DarkSide-50, we both actively suppress and measure the rate of neutron-induced background events using our neutron veto, composed of a boron-loaded liquid scintillator detector within a water Cherenkov detector. This paper is devoted to the description of the neutron veto system of DarkSide-50, including the detector structure, the fundamentals of event reconstruction and data analysis, and basic performance parameters.
• Measurement of Scintillation and Ionization Yield and Scintillation Pulse Shape from Nuclear Recoils in Liquid Argon(1406.4825)

May 27, 2015 hep-ex, physics.ins-det
We have measured the scintillation and ionization yield of recoiling nuclei in liquid argon as a function of applied electric field by exposing a dual-phase liquid argon time projection chamber (LAr-TPC) to a low energy pulsed narrow band neutron beam produced at the Notre Dame Institute for Structure and Nuclear Astrophysics. Liquid scintillation counters were arranged to detect and identify neutrons scattered in the TPC and to select the energy of the recoiling nuclei. We report measurements of the scintillation yields for nuclear recoils with energies from 10.3 to 57.3 keV and for median applied electric fields from 0 to 970 V/cm. For the ionization yields, we report measurements from 16.9 to 57.3 keV and for electric fields from 96.4 to 486 V/cm. We also report the observation of an anticorrelation between scintillation and ionization from nuclear recoils, which is similar to the anticorrelation between scintillation and ionization from electron recoils. Assuming that the energy loss partitions into excitons and ion pairs from $^{83m}$Kr internal conversion electrons is comparable to that from $^{207}$Bi conversion electrons, we obtained the numbers of excitons ($N_{ex}$) and ion pairs ($N_i$) and their ratio ($N_{ex}/N_i$) produced by nuclear recoils from 16.9 to 57.3 keV. Motivated by arguments suggesting direction sensitivity in LAr-TPC signals due to columnar recombination, a comparison of the light and charge yield of recoils parallel and perpendicular to the applied electric field is presented for the first time.
• First Results from the DarkSide-50 Dark Matter Experiment at Laboratori Nazionali del Gran Sasso(1410.0653)

We report the first results of DarkSide-50, a direct search for dark matter operating in the underground Laboratori Nazionali del Gran Sasso (LNGS) and searching for the rare nuclear recoils possibly induced by weakly interacting massive particles (WIMPs). The dark matter detector is a Liquid Argon Time Projection Chamber with a (46.4+-0.7) kg active mass, operated inside a 30 t organic liquid scintillator neutron veto, which is in turn installed at the center of a 1 kt water Cherenkov veto for the residual flux of cosmic rays. We report here the null results of a dark matter search for a (1422+-67) kg d exposure with an atmospheric argon fill. This is the most sensitive dark matter search performed with an argon target, corresponding to a 90% CL upper limit on the WIMP-nucleon spin-independent cross section of 6.1x10^-44 cm^2 for a WIMP mass of 100 GeV/c^2.
• The Electronics and Data Acquisition System of the DarkSide Dark Matter Search(1412.2969)

Jan. 22, 2015 physics.ins-det, astro-ph.IM
It is generally inferred from astronomical measurements that Dark Matter (DM) comprises approximately 27\% of the energy-density of the universe. If DM is a subatomic particle, a possible candidate is a Weakly Interacting Massive Particle (WIMP), and the DarkSide-50 (DS) experiment is a direct search for evidence of WIMP-nuclear collisions. DS is located underground at the Laboratori Nazionali del Gran Sasso (LNGS) in Italy, and consists of three active, embedded components; an outer water veto (CTF), a liquid scintillator veto (LSV), and a liquid argon (LAr) time projection chamber (TPC). This paper describes the data acquisition and electronic systems of the DS detectors, designed to detect the residual ionization from such collisions.
• Observation of the Dependence of Scintillation from Nuclear Recoils in Liquid Argon on Drift Field(1306.5675)

Dec. 16, 2013 hep-ex, physics.ins-det
We have exposed a dual-phase Liquid Argon Time Projection Chamber (LAr-TPC) to a low energy pulsed narrowband neutron beam, produced at the Notre Dame Institute for Structure and Nuclear Astrophysics to study the scintillation light yield of recoiling nuclei in a LAr-TPC. A liquid scintillation counter was arranged to detect and identify neutrons scattered in the LAr-TPC target and to select the energy of the recoiling nuclei. We report the observation of a significant dependence on drift field of liquid argon scintillation from nuclear recoils of 11 keV. This observation is important because, to date, estimates of the sensitivity of noble liquid TPC dark matter searches are based on the assumption that electric field has only a small effect on the light yield from nuclear recoils.
• Raman Spectroscopy of Graphene Edges(0810.5358)

Oct. 29, 2008 cond-mat.mtrl-sci
Graphene edges are of particular interest, since their chirality determines the electronic properties. Here we present a detailed Raman investigation of graphene flakes with well defined edges oriented at different crystallographic directions. The position, width and intensity of G and D peaks at the edges are studied as a function of the incident light polarization. The D-band is strongest for light polarized parallel to the edge and minimum for perpendicular orientation. Raman mapping shows that the D peak is localized in proximity of the edge. The D to G ratio does not always show a significant dependence on edge orientation. Thus, even though edges can appear macroscopically smooth and oriented at well defined angles, they are not necessarily microscopically ordered.
• Rayleigh Imaging of Graphene and Graphene Layers(0705.2645)

May 18, 2007 cond-mat.mtrl-sci
We investigate graphene and graphene layers on different substrates by monochromatic and white-light confocal Rayleigh scattering microscopy. The image contrast depends sensitively on the dielectric properties of the sample as well as the substrate geometry and can be described quantitatively using the complex refractive index of bulk graphite. For few layers (<6) the monochromatic contrast increases linearly with thickness: the samples behave as a superposition of single sheets which act as independent two dimensional electron gases. Thus, Rayleigh imaging is a general, simple and quick tool to identify graphene layers, that is readily combined with Raman scattering, which provides structural identification.
• On the existence of potential landscape in the evolution of complex systems(q-bio/0703044)

A recently developed treatment of stochastic processes leads to the construction of a potential landscape for the dynamical evolution of complex systems. Since the existence of a potential function in generic settings has been frequently questioned in literature,herewe study several related theoretical issues that lie at core of the construction. We showthat the novel treatment,via a transformation,is closely related to the symplectic structure that is central in many branches of theoretical physics. Using this insight, we demonstrate an invariant under the transformation. We further explicitly demonstrate, in one-dimensional case, the contradistinction among the new treatment to those of Ito and Stratonovich, as well as others.Our results strongly suggest that the method from statistical physics can be useful in studying stochastic, complex systems in general.


text:
# Development crash course¶

This document describes a short crash-course for numba development, where things are and where we want them at.

## Overview¶

We start with a Python AST, compiled from source code or decompiled from bytecode using meta. We run a series of stages that transform the program as an AST to something from which we can generate code. The pipeline and environment are central pieces in this story:

### Stages¶

The main stages are:

• Control flow analysis: numba/control_flow

This builds a Control Flow Graph from the AST and computes the SSA graph for the variable definitions. In this representation, each variable assignment is a definition, e.g.:

x = 0         # definition 1
x = "hello"   # definition 2

Assignments and variable references are recorded as abstract statements in the basic blocks of the CFG, such as

• numba.control_flow.cfstats.NameAssignment
• numba.control_flow.cfstats.NameReference
• numba.control_flow.cfstats.PhiNode

The phi node occurs at control flow joint points, e.g. after an if-statement, or in the condition block of a loop with a loop-carried dependency for a variable:

if c:
x = 0
else:
x = 2
# phi here

and:

x = 0
for i in range(N):  # phi in condition block: x_1 = phi(x_0, x_2)
x = x + i # loop-carried dependency

The phi nodes are themselves variable definitions, and they define the points where variables merge and need a unifyable type (e.g. (int, int), or (int, float), as opposed to (int, string)).

• Type inference: numba.type_inference

Infer types of all expressions, and fix the types of all local variables. This operates in two stages:

• Infer types for all local variable definitions (including phis)

For an overview of this see Type Dependence Graph Construction below.

• Now that all variable definitions have a type, we can easily infer types for all expressions by propagating type information up the tree

When the type inferencer cannot determine a type, such as when it
calls a Python function or method that is not a Numba function, it
assumes type object. Object variables may be coerced to and from
most native types.
The type inferencer and other code insert CoercionNode nodes that
perform such coercions, as well as coercions between promotable
native types.
It also resolves the return type of many math functions called
in the numpy, math and cmath modules.
Each AST expression node has a Variable that holds the type of
the expression, as well as any meta-data such as constant values
that have been determined.
To see how builtins, math and numpy callables are handled, have
a read through Adding Type Inference for External Code in the user documentation,
as well as numba.type_inference.modules::
This above sub-package is an important part of numba that
infers (and sometimes grossly rewrites) calls to known functions.
• Specialization/Lowering: numba/specialize and numba/transforms.py

What follows over the typed code are a series of transformations to lower the level of the code into something low-level - something amenable to code generation:

• Rewrite loops over range or xrange into a while loop with a counter

• Rewrite iteration over arrays to a loop over range with an index into the array

• Lower object conversions into calls into the Python C-API. For instance it resolves coercions to and from object into calls such as PyFloat_FromDouble, with a fallback to Py_BuildValue/PyArg_ParseTuple.

• Lower exception code into calls into the C-API and insert NULL pointer checks in places

• Normalize comparisons (e.g. a < b < c => a < b and b < c)

• Keep track of refcounts. This is mostly done with ObjectTempNode, which hold a temporary for an object (a new reference). These temporaries are decreffed at cleanup:

define double @func()  {
entry:
%retval = alloca double           ; return value
%tmp = alloca object              ; object temporary
...
%obj = call PyObject_SomeNewObject()
%have_error = cmp obj NULL        ; check return value
cbranch %have_error, label %error, label %success

success:                            ; no error
do something interesting with %obj
store %something %retval          ; return some value
br return_block                   ; ok, we're done

error:                              ; some error occurred :(
store NaN retval
br cleanup

return_block:                       ; clean up objects
call void Py_XDECREF(%0)
ret %result                       ; return result
}
• Code generation: numba/codegen

Generate LLVM code from the transformed AST. This is relatively straightforward at this point. One tricky problem is that the basic blocks from the LLVM code no longer correspond to the basic blocks of the CFG, since error checks have been inserted. This makes tracking phis harder than it should be.

The code generator uses utility functions from numba/utility and numba/external to do things like refcounting (Py_INCREF, etc) and uses helpers to slice and broadcast arrays.

#### Package Structure¶

• numba/type_inference

Type inference

• numba/typesystem

• numba/specialize

Lowering transformations, along with numba/transforms.py . Coercions are in numba/transforms.py

• numba/nodes

Contains AST nodes. Some nodes that need some explaining:

• ObjectTempNode:

Holds a PyObject * temporary that it manages a refcount for

• CloneNode/CloneableNode:

These nodes are used for subtree sharing, to avoid re-evaluation of the subtree. Consider e.g. the expression ‘x * 2’, which we want to refer to twice, but evaluate once. We can do the following:

cloneable = CloneableNode(<x * 2 expression>)
clone  = CloneNode(cloneable)

Here cloneable must be evaluated before clone. We can now generate as many clones as we want without re-evaluating x * 2

• numba/exttypes

Numba extension types, have a read through Extension Types (Classes) first. These are fairly well documented. To see how they work, see below Extension Classes

• numba/closures

Implements closures for numba. See Closures and closureimpl below for how they work.

• numba/support

Ctypes, CFFI and NumPy support (slicing, etc)

• numba/array_expressions.py

Implements array expressions using minivect. Since we don’t actually use the tiling specializers or desperately need crazy optimizations for special cases, we should really use lair’s loop_nest instead and throw away numba/minivect

• numba/vectorize

The @vectorize functionality to build (generalized) ufuncs

• numba/wrapping

Entry points to compile numba functions, classes and methods

• numba/utility and numba/external

Runtime support utilities. And yes, you make a valid point, this should really be one package.

• numba/intrinsic

Intrinsics and instruction support for numba, as well as... internal intrinsics. Merge internal stuff in numba/external :)

See Using Intrinsics for what intrinsics do.

• numba/containers

Numba typed containers, see Typed Containers

• numba/asdl and numba/ir

Utilities to validate ASTs and generate fast visitors/AST implementations from ASDL. This should be factored out into asdlpy or somesuch.

• numba/viz

• numba/minivect

Array expression compiler. numba.array_expressions is the only remaining module depending on this. However, since none of the optimizations are actually used, it doens’t make sense to keep this. Instead we can use the loop_nest function from the lair project.

More on how the array expressions work: Array Expressions

#### Type Dependence Graph Construction¶

From the SSA graph we compute a type graph by inferring all variable assignments. This graph often has cycles, due to the back-edge in the CFG for loops. For instance we may have the following code:

x = 0
for i in range(10):
x = f(x)

y = x

Where f is an external autojit function (i.e., it’s output type depends on it’s dynamic input type).

We get the following type graph:

Below we show the correspondence of the SSA variable definitions to their basic blocks:

Our goal is to resolve this type graph in topological order, such that we know the type for each variable definition (x_0, x_1, etc).

In order to do a topological sort, we compute the condensation graph by finding the strongly connected components and condensing them into single graph nodes. The resulting graph looks like this:

And SCC0 contains the cycle in the type graph. We now have a well-defined preorder for which we can process each node in topological order on the transpose graph, doing the following:

• If the node represents a concrete type, propagate result along edge
• If the node represents a function over an argument of the given input types, infer the result type of this function
• For each SCC, process all internal nodes using fixpoint iteration given all input types to the SCC. Update internal nodes with their result types.

#### Closures¶

numba/closures.py provides support for closures and inner functions:

@autojit
def outer():
a = 10 # this is a cellvar

@jit('void()')
def inner():
print a # this is a freevar

inner()
a = 12
return inner

The ‘inner’ function closes over the outer scope. Each function with cellvars packs them into a heap-allocated structure, the closure scope.

The closure scope is passed into ‘inner’ when called from within outer.

The execution of def creates a NumbaFunction, which has itself as the m_self attribute. So when ‘inner’ is invoked from Python, the numba wrapper function gets called with NumbaFunction object and the args tuple. The closure scope is then set in NumbaFunction.func_closure.

The closure scope is an extension type with the cellvars as attributes. Closure scopes are chained together, since multiple inner scopes may need to share a single outer scope. E.g.:

def outer(a):
def inner(b):
def inner_inner():
print a, b
return inner_inner

return inner(1), inner(2)

We have three live closure scopes here:

scope_outer = { 'a': a }  # call to 'outer'
scope_inner_1 = { 'scope_outer': scope_outer, 'b': 1 } # call to 'inner' with b=1
scope_inner_2 = { 'scope_outer': scope_outer, 'b': 2 } # call to 'inner' with b=2

Function ‘inner_inner’ defines no new scope, since it contains no cellvars. But it does contain a freevar from scope_outer and scope_inner, so it gets scope_inner passed as first argument. scope_inner has a reference to scope outer, so all variables can be resolved.

These scopes are instances of dynamic numba extension classes.

#### Extension Classes¶

Extension classes live in numba/exttypes.

### @jit¶

Compiling @jit extension classes works as follows:

• Create an extension Numba type holding a symbol table

• Capture attribute types in the symtab ...

• ... from the class attributes:

@jit
class Foo(object):
attr = double

• ... from __init__:

@jit
class Foo(object):
def __init__(self, attr):
self.attr = double(attr)

• Type infer all methods

• Compile all extension methods

• Process signatures such as @void(double)
• Infer native attributes through type inference on __init__
• Path the extension type with a native attributes struct
• Infer types for all other methods
• Update the ext_type with a vtab type
• Compile all methods
• Create descriptors that wrap the native attributes

• Create an extension type:

{

PyObject_HEAD ... virtual function table (func **) native attributes

}

The virtual function table (vtab) is a ctypes structure set as attribute of the extension types. Objects have a direct pointer for efficiency.

### @autojit¶

Compiling @autojit extension classes works as follows:

• Create an extension Numba type holding a symtab

• Capture attribute types in the symtab in the same was as @jit

• Build attribute hash-based vtable, hashing on (attr_name, attr_type).

(attr_name, attr_type) is the only allowed key for that attribute (i.e. this is fixed at compile time (for now). This means consumers will always know the attribute type (and don’t need to specialize on different attribute types).

However, using a hash-based attribute table allows easy implementation of multiple inheritance (virtual inheritance), without complicated C++ dynamic offsets to base objects (see also virtual.py).

For all methods M with static input types:
• Compile M
• Register M in a list of compiled methods
• Build initial hash-based virtual method table from compiled methods

• Create pre-hash values for the signatures
• We use these values to look up methods at runtime
• Parametrize the virtual method table to build a final hash function:

slot_index = (((prehash >> table.r) & self.table.m_f) ^
self.displacements[prehash & self.table.m_g])

Note that for @jit classes, we do not support multiple inheritance with incompatible base objects. We could use a dynamic offset to base classes, and adjust object pointers for method calls, like in C++:

However, this is quite complicated, and still doesn’t allow dynamic extension for autojit classes. Instead we will use Dag Sverre Seljebotn’s hash-based virtual method tables:

The following paper helps understand the perfect hashing scheme:

Hash and Displace: Efficient Evaluation of Minimal Perfect Hash Functions (1999) by Rasmus Pagn:

• Create descriptors that wrap the native attributes

• Create an extension type:

{
hash-based virtual method table (PyCustomSlots_Table **)
...
native attributes
}

We precede the object with the table to make this work in a more generic scheme, e.g. where a caller is dealing with an unknown object, and we quickly want to see whether it support such a perfect-hashing virtual method table:

NOTE: What we want is to actually use a separate attribute table

in addition to the virtual method table, giving all extension objects a compatible layout.

if (o->ob_type->tp_flags & NATIVELY_CALLABLE_TABLE) {
PyCustomSlots_Table ***slot_p = ((char *) o) - sizeof(PyGC_HEAD)
PyCustomSlots_Table *vtab = **slot_p
look up function
} else {
PyObject_Call(...)
}

We need to store a PyCustomSlots_Table ** in the object to allow the producer of the table to replace the table with a new table for all live objects (e.g. by adding a specialization for an autojit method).

#### Wrappers¶

There are several wrappers in numba that wrap functions, classes and methods. The key implementations are in:

• numba/numbawrapper.pyx
• numba/numbafunction.c
• numba/codegen/llvmwrapper.py

What numba does is it creates a function like this (in C pseudo-code):

double square(double arg) {
return arg * arg;
}

and it wraps it as follows:

PyObject *square_wrapper(PyObject *self, PyObject *args) {
double arg;

if (!PyArg_ParseTuple(args, "d", &arg))
return NULL;

return PyFloat_FromDouble(square(arg));
}

The wrapper is a CPython compatible function the likes of which you often see in extension modules. It is created by llvmwrapper.py. This wrapper is turned into an PyCFunctionObject, defined in Include/methodobject.h in CPython’s source tree:

typedef struct {
PyMethodDef *m_ml; /* Description of the C function to call */
PyObject    *m_self; /* Passed as 'self' arg to the C func, can be NULL */
PyObject    *m_module; /* The __module__ attribute, can be anything */
} PyCFunctionObject;

Numba uses a wrapper (a subclass) of PyCFunctionObject, called numbafunction, which has some extra fields and gives the function a more pythonic interface, such as a dict, a way to override __doc__, etc. It also has a field to hold a closure frame (see Closures).

This function object is created after compilation of the function and its wrapper (square_wrapper). It is instantiated in llvmwrapper.py:numbafunction_new, calling NumbaFunction_NewEx.

### @jit¶

Jit functions are wrapped typically by the NumbaFunction in numbafunction.c. The NumbaCompiledWrapper is only a temporary wrapper used in case of a recursive function that is still being compiled, and for which we have no pointer.

### @autojit¶

Autojit functions are handled by NumbaSpecializingWrapper, which wraps a Python function and when called does a lookup in a cache to see if a previously compiled version is available. This code in in numbawrapper.pyx.

NumbaSpecializingWrapper holds an AutojitCache which tries to find a match very quickly. However, it may not always find a compiled version even though it’s in the cache, for instance because there are values of different Python types which are represented using the same numba type.

This is then corrected by a slower path which tries to compile the function, and creates a type for each argument. It uses these types to do a lookup in numba.functions.FunctionCache.

### classes¶

The story for classes is slightly different. @jit classes are simply turned into a compiled extension type, with compiled methods set as class attributes. The NumbaFunction handles binding to bound or unbound methods.

@autojit classes are wrapped in the same way as autojit functions, but with a different compiler entry point that triggers when the wrapper is called. The entry point compiles a special version of the extension class, and any methods that are not specialized (e.g. because they take further arguments than self), are wrapped by wrappers (again NumbaSpecializingWrapper) that compile a method on call and update the method table (the table supporting fast call from numba space).

The only special case are unbound methods, consider the code below:

from numba import *

@autojit
class A(object):
def __init__(self, arg):
self.arg = arg

return self.arg * other

print A(10).exttype     # <AutojitExtension A({'arg': int})>
print A(10.0).exttype   # <AutojitExtension A({'arg': float64})>

We have two versions of our extension type, one with arg = int and one with arg = float64. Now consider calling add as an unbound method:

print A.add(A(10.0), 5.0)   # 50.0

To dispatch from unbound method A.add of unspecialized class A to specialized method A[{'arg':int_}].add, numba creates a UnboundDelegatingMethod defined in numba.exttypes.autojitclass.

#### Array Expressions¶

Array expressions live in numba.array_expressions. Array expressions roughly work as follows:

• Detect array expressions (ArrayExpressionRewrite)

This code finds a maximal sub-expression that operates on arrays, e.g. A + B * C. These expressions are captured via register_array_expression.

• The registered expression is extracted using get_py_ufunc_ast. This function traverses the subexpression and does the following:

• demote types from arrays to scalars
• register any non-array sub-expression of our expression as an operand. More on this below.
• Compile the extracted sub-expression as a seprate function

• Generate a loop nest using minivect that calls this compiled function

Let’s walk through an example, consider for argument’s sake the following expression:

A + sin(B) * g(x)

Where g(x) returns a scalar and is not part of the array expression. Our AST looks like this:

We take this expression and build a function with g(x) as operand:

def kernel(op0, op1, op2):
return op0 + sin(op1) * op2

Each operation acts on scalars. Note that the g(x) is not part of the kernel. We now use minivect to generate a loop nest, e.g. for 2D arrays:

def loop_nest(shape, result, A, B, g_of_x):
for i in range(shape[0]):
for j in range(shape[1]):
result[i, j] = kernel(A[i, j], B[i, j], g_of_x)

Result is allocated, or in cases of slice assignment it is the LHS:

LHS[:, :] = A + sin(B) * g(x)

The passed in shape is the broadcasted result of the shapes of A and B:

shape = broadcast(A.shape, B.shape)
result = np.empty(shape)
loop_nest(shape, result, A, B, g(x))

#### Testing¶

Whenever you make changes to the code, you should see what impact this has on by running the test suite:

$python runtests.py # run whole test suite$ python runtests.py mypackage      # run tests under mypackage
$python runtests.py mypkg.mymod # run test(s) matched by mypkg.mymod  The test runner matches by substring, i.e.: $ python runtests.py conv
Running tests in /home/mark/numba/numba/numba
numba.tests.test_object_conversion                                     SUCCESS
numba.typesystem.tests.test_conversion                                 SUCCESS

To isolate problems it’s best to create an isolated test-case that is as small as possible yet still exhibits the problem, often using just a simple test script.

Debugging compiler tracebacks can be handled through prints, but if the problem is less obvious (or the codebase unfamiliar) it is often simpler to use post-mortem debugging, which can help understand what’s going wrong without modifying any code (and later tracking down print statements that you accidentally committed):

\$ python -m pdb test.py

When using post-mortem debugging it’s useful to enable the post-mortem option in numba.environment.FunctionErrorEnvironment:

enable_post_mortem = TypedProperty(
bool,
"Enable post-mortem debugging for the Numba compiler",
False
)

Set the default value to True there. This way exceptions are not swallowed and accumulated (and hence raised from the error reporter, instead of the failing place in the compiler).

#### Debugging¶

Depending on the nature of the problem, there are some tools available for debugging what’s going on. In the annotate branch there is functionality to debug pretty-print to the terminal, create a graphviz visualization or generate a webpage:

usage: numba [-h] [--annotate] [--dump-llvm] [--dump-optimized] [--dump-cfg]
[--dump-ast] [--fancy]
filename

positional arguments:
filename          Python source filename

optional arguments:
-h, --help        show this help message and exit
--annotate        Annotate source
--dump-llvm       Print generated llvm assembly
--dump-optimized  Dump the optimized llvm assembly
--dump-cfg        Dump the control flow graph
--dump-ast        Dump the AST
--fancy           Try to output fancy files (.dot or .html)

The --annotate feature also prints the types of each variable used in a certain expression.

### Debugging ASTs¶

You get more control over when the AST is dumped by adding the dump_ast stage in numba.environment at the right place in the pipeline. If you just quickly want to debug print an AST from Python, there is:

• ast.dump(mynode)
• utils.pformat_ast or utils.dump

It can also help sometimes to look at an instance of the data of certain piece of code is dealing with interactively, to try and make sense of what is happening. You can do this with a breakpoint using your favorite Python debugger, e.g. import pdb; pdb.set_trace().

### Debugging Types¶

Debugging types can be tricky, but something that is often valuable is numba.typeof:

@jit(...)
def myfunc(...):
...
print(numba.typeof(x))
print(numba.typeof(x + y))

You can also always force types through casts or locals:

@jit(..., locals={'x':double}) # locals
def myfunc(...):
print(double(y))           # cast

### Debugging the Translator¶

To debug the translator, one can again stick with prints or post-mortem debugging. If the latter option is desirable, make absolutely sure that you enable the post-mortem debug option (see post-mortem). This makes sure numba does not delete the LLVM function, which means the LLVM values referenced in the translator will still be in a consistent state.

#### Problems¶

There are several problems with the codebase, stemming from our IR. The AST is too high level for most of the operations that we need to do, and has too much information, which leads to code having to deal with different in-memory formats that are doing similar things - which should be encoded in a uniform way. Consider e.g. the following code:

x = range(N)
for i in x:
...

# And
for i in range(N):
...

The code that detects and transforms iteration over range should be written in a uniform way, depending on the flow of values irregardless of the syntax. Besides the level of information ASTs are not always amenable to transformations, e.g. when you want to execute some statements in the middle of an expression, or when you want to share a subtree (see the Clone(able)Node discussion above nodes).

Another issue is that refcounting and the Python C-API as well as NumPy are baked into the transformations. Coupling these APIs like this can be a real problem when you want to switch to a different runtime environment or library (CPython, NumPy).

format: plain


text:
# Using Aspect Extraction Approaches to Generate Review Summaries and User Profiles

(Mitcheltree, Wharton, and Saluja, 2018) at NAACL

I’m incredibly proud of a friend that I met in elementary school, Veronica Wharton, for her publication at NAACL this year. She and her colleagues at Airbnb have exploited maximum entropy classifiers to pick apart users’ reviews.

There are two tasks in question here:

1. Information retrieval: picking out the sentence that exemplifies some aspect of the reviewed accommodation—cleanliness, communication with the host, location, and ‘other’.
2. Learning to rank: producing embeddings for each guest from their reviews. Using these embeddings to determine how users appraise accommodations relative to one another.

The authors rely on the distributional hypothesis to include co-occurrence information: words are represented by vectors that are trained to incorporate their context. Words with similar contexts get similar vectors. A sentence is a matrix of one vector for each word. Because these are variable-size, all sentences are squeezed into a common size by a self-attention mechanism (Lin et al., 2017).

Their method of extracting aspects presupposes the number of aspects, so they test different values and evaluate them using a ‘coherence score’. These aspects are then condensed into the four categories mentioned above by hand. (Why not community detection on these?) It also sits on top of $k$-means as initialization (so no wonder it outperforms $k$-means?). I hope they ran multiple rounds of $k$-means—$k$-means itself is sensitive to initialization.

When the authors produce guest embeddings, they evaluate them by comparing the distance between them to the difference in ratings given by the users.

Written on June 7, 2018


text:
Find all School-related info fast with the new School-Specific MBA Forum

 It is currently 10 Feb 2016, 04:55

### GMAT Club Daily Prep

#### Thank you for using the timer - this advanced tool can estimate your performance and suggest more practice questions. We have subscribed you to Daily Prep Questions via email.

Customized
for You

we will pick new questions that match your level based on your Timer History

Track

every week, we’ll send you an estimated GMAT score based on your performance

Practice
Pays

we will pick new questions that match your level based on your Timer History

# Events & Promotions

###### Events & Promotions in June
Open Detailed Calendar

# Careers in finance Post MBA

Author Message
TAGS:
Current Student
Joined: 04 Dec 2006
Posts: 440
Followers: 1

Kudos [?]: 6 [0], given: 0

Careers in finance Post MBA [#permalink]  03 Apr 2007, 06:37
So I am pretty sure I want to go into MC post-MBA but was toying with finance. The only problem is I am extremely limited in my knowledge about the options. I know that I like a pretty high level of social time and limited number crunching time. Anyone have any suggestions. Any input or field in finance that you have knowledge would be beneficial to me as I pretty much have 0 knowledge. Thanks!
Senior Manager
Joined: 05 Oct 2005
Posts: 485
Followers: 1

Kudos [?]: 2 [0], given: 0

Here are some:

1) Investment Banking

2) Equity Research

4) Investment Management

5) Private Equity

6) Venture Capital

7) Commercial Banking

8) Corporate Finance

Any others?

5 & 6 are apparently tough to get into w/o previous IB/transaction experience or if you're coming out of a top-school or if you have awesome contacts. Correct me if I'm wrong.
Director
Joined: 28 Jun 2006
Posts: 958
Followers: 1

Kudos [?]: 74 [0], given: 0

I'm thinking the same thing, MC would be great, but corporate finance might be more appealing given the "life balance" that it affords.

I work in healthcare finance which would fall under "corporate finance" or "industry finance" depending on people's definition. I think this is a pretty good place to be in terms of compensation and quality of life. The work is interesting, and it's a very "niche-y" sort of place, such that you get to know people in the local market very quickly. Having been in this industry for only four years, I feel like if I got fired tomorrow, I could have several job offers by the end of the month because I have such a great network of colleagues/friends who work in different organizations. What we do is so specialized that companies really offer up some good money to recruit people away from one organization to another. I suspect this is the same story with any sort of niche finance industry. Probably not the case if you're doing finance work at a financial services bank, or an insurance company etc....
Current Student
Joined: 04 Dec 2006
Posts: 440
Followers: 1

Kudos [?]: 6 [0], given: 0

johnnyx9 wrote:
I'm thinking the same thing, MC would be great, but corporate finance might be more appealing given the "life balance" that it affords.

I work in healthcare finance which would fall under "corporate finance" or "industry finance" depending on people's definition. I think this is a pretty good place to be in terms of compensation and quality of life. The work is interesting, and it's a very "niche-y" sort of place, such that you get to know people in the local market very quickly. Having been in this industry for only four years, I feel like if I got fired tomorrow, I could have several job offers by the end of the month because I have such a great network of colleagues/friends who work in different organizations. What we do is so specialized that companies really offer up some good money to recruit people away from one organization to another. I suspect this is the same story with any sort of niche finance industry. Probably not the case if you're doing finance work at a financial services bank, or an insurance company etc....

What exactly do you do? What would a "day in the life" read like, if you do not mind divulging that info.
Manager
Joined: 20 Nov 2005
Posts: 188
Location: USA
Followers: 1

Kudos [?]: 2 [0], given: 0

johnnyx9 wrote:
I'm thinking the same thing, MC would be great, but corporate finance might be more appealing given the "life balance" that it affords.

I work in healthcare finance which would fall under "corporate finance" or "industry finance" depending on people's definition. I think this is a pretty good place to be in terms of compensation and quality of life. The work is interesting, and it's a very "niche-y" sort of place, such that you get to know people in the local market very quickly. Having been in this industry for only four years, I feel like if I got fired tomorrow, I could have several job offers by the end of the month because I have such a great network of colleagues/friends who work in different organizations. What we do is so specialized that companies really offer up some good money to recruit people away from one organization to another. I suspect this is the same story with any sort of niche finance industry. Probably not the case if you're doing finance work at a financial services bank, or an insurance company etc....

copying from squali83:

What exactly do you do? What would a "day in the life" read like, if you do not mind divulging that info.
Director
Joined: 28 Jun 2006
Posts: 958
Followers: 1

Kudos [?]: 74 [0], given: 0

I work for a network of hospitals and physicians. We basically take care of all of their "finance" needs. Within my organization, the group I work in focuses on doing collective negotiating with insurance companies. The financial arrangement behind these deals can be quite complicated, so there is a lot of modeling that needs to be done during the negotiations cycle. There are also incentives built into the contracts that involve clinical performance goals, so some of our work involves looking at historical clinical data and making projections. For instance, if Insurance Company X offers discounted rates provided we can lower our high cost radiology treatments by a certain percentage, my group needs to analyze radiology data to see what a realistic goal might be.

Once the contracts are done, then they need to be implemented, and there are other functions that need to be tended to, such as projecting each hospital's exposure under the agreements, and providing them with these financial projections so they can properly account for these exposures in their financials.

A typical day involves maybe three meetings, usually don't have to go off-site, although I do have a couple of those meetings a week. The rest of the time is spent doing analytical work around the things I mentioned above. Generally work 40-50 hours a week, although every few months I'll have a busy week that's closer to 60.

The heirarchy goes like this: analyst, senior analyst, manager, director, VP, CFO. I imagine this is pretty similar to most corporate or "industry" finance organizations.

I think someone coming out of b-school could start out as a senior analyst or manager making 90-120K depending on their previous experience. I think a director level position is probably more like 140-200K, which could probably be attained maybe four or five years after graduating b-school. I think managers and directors work around 50-60 hours.

Not super-lucrative like most industries people are interested in on these boards, but the hours are pretty good. Something I'm thinking about if I decide MC isn't my thing.
Current Student
Joined: 04 Dec 2006
Posts: 440
Followers: 1

Kudos [?]: 6 [0], given: 0

johnnyx9 wrote:
I work for a network of hospitals and physicians. We basically take care of all of their "finance" needs. Within my organization, the group I work in focuses on doing collective negotiating with insurance companies. The financial arrangement behind these deals can be quite complicated, so there is a lot of modeling that needs to be done during the negotiations cycle. There are also incentives built into the contracts that involve clinical performance goals, so some of our work involves looking at historical clinical data and making projections. For instance, if Insurance Company X offers discounted rates provided we can lower our high cost radiology treatments by a certain percentage, my group needs to analyze radiology data to see what a realistic goal might be.

Once the contracts are done, then they need to be implemented, and there are other functions that need to be tended to, such as projecting each hospital's exposure under the agreements, and providing them with these financial projections so they can properly account for these exposures in their financials.

A typical day involves maybe three meetings, usually don't have to go off-site, although I do have a couple of those meetings a week. The rest of the time is spent doing analytical work around the things I mentioned above. Generally work 40-50 hours a week, although every few months I'll have a busy week that's closer to 60.

The heirarchy goes like this: analyst, senior analyst, manager, director, VP, CFO. I imagine this is pretty similar to most corporate or "industry" finance organizations.

I think someone coming out of b-school could start out as a senior analyst or manager making 90-120K depending on their previous experience. I think a director level position is probably more like 140-200K, which could probably be attained maybe four or five years after graduating b-school. I think managers and directors work around 50-60 hours.

Not super-lucrative like most industries people are interested in on these boards, but the hours are pretty good. Something I'm thinking about if I decide MC isn't my thing.

That does sound like a very interesting field. If I do go into finance I would prefer to be on the negotiating side of the table. Numbers just are not my thing. Thanks for the insight.
Senior Manager
Joined: 08 Feb 2006
Posts: 251
Schools: Ross, Kellogg, Darden (i/v)
Followers: 1

Kudos [?]: 9 [0], given: 0

Quote:
I think someone coming out of b-school could start out as a senior analyst or manager making 90-120K depending on their previous experience. I think a director level position is probably more like 140-200K, which could probably be attained maybe four or five years after graduating b-school. I think managers and directors work around 50-60 hours.

50-60 hours??? Wow!!
120k for a 60 hr/week job is supercool!!
Senior Manager
Joined: 12 Nov 2006
Posts: 469
Followers: 1

Kudos [?]: 8 [0], given: 0

Good info. I am also interested in hearing similar info (compensation, advancement prigression, day in the life, etc) for the other finance sub-fields such as Sales and Trading, PE, IB (is it that horrible?).

Thanks.
VP
Joined: 11 Dec 2006
Posts: 1429
Location: New York, NY
Schools: NYU Stern 2009
Followers: 41

Kudos [?]: 219 [0], given: 6

aceman - all of those are difficult to give. Basic salaries are the only true measurable but bonus is a huge part of those roles and is performance related.

Really all are comparable, and it is more what interests you. PE & IB (M&A) are hugely cyclical businesses driven by the yield curve and business cycle respectively. If you are there at the right time, the numbers are very big indeed.

If you are talking any career in the above each company will deem itself very much a meritocracy. This is basically judged on the fact that if you make lots of money, you will get career progression quickly. Similar if you don't make money, you will find yourself unemployed.

Day in the life stuff isn't going to be my forte, but I wouldn't expect PE to be much different than M&A IB as they are to all intents and purposes the same business.
Senior Manager
Joined: 03 Aug 2006
Posts: 444
Followers: 1

Kudos [?]: 4 [0], given: 0

Although it is close to fictional, it does convey some truth about IB.

Are you willing to go through all that non-sense crap to make 250K+?
Are you mentally capable of actually going through all these crap?
Is the $$most important in your life? If you answer yes to all these three questions, you should consider IB. I do like$$ but not that much.
Senior Manager
Joined: 03 Aug 2006
Posts: 444
Followers: 1

Kudos [?]: 4 [0], given: 0

I just finished reading the Monkey Biz.
Not just because of this book, but based on my info gathering, the last thing I want to do is the IB.
SVP
Joined: 31 Jul 2006
Posts: 2304
Schools: Darden
Followers: 42

Kudos [?]: 451 [0], given: 0

I agree that IB in NY can be brutal. Of course, the vast majority of IB positions are in NY (talking about US domestic only). I believe that a substantial part of the IB crappyness stems from working in NY, and not necessarily the IB profession.

If you are able to land an IB position outside of NY, I think you'll work fewer hours, deal with less crap and have a measurably better quality of life. The downside is that if you are away from NY, your chances of moving up the ladder may be reduced. The other problem is that IB jobs outside of NY are really hard to land. I think SF is the next biggest destination, but competition is really tough. LA might be a little easier, and you'll find some related positions in Chicago & Houston as well, which should be less competitive.
VP
Joined: 11 Dec 2006
Posts: 1429
Location: New York, NY
Schools: NYU Stern 2009
Followers: 41

Kudos [?]: 219 [0], given: 6

pelihu wrote:
I agree that IB in NY can be brutal. Of course, the vast majority of IB positions are in NY (talking about US domestic only). I believe that a substantial part of the IB crappyness stems from working in NY, and not necessarily the IB profession.

Any IB is pretty bad, though my friend who works in Chicago has it a bit easier (but is still tempted to go back to NYC, despite these reasons). The problem is that the big deals are in NYC, the big deals need more work in the same time scales, so longer hours.

Working in a satellite office has less hours, less work, less money, less recognition. Any hub city is a lot more (NYC, London, etc)
SVP
Joined: 31 Jul 2006
Posts: 2304
Schools: Darden
Followers: 42

Kudos [?]: 451 [0], given: 0

3underscore wrote:
Working in a satelitte office has less hours, less work, less money, less recognition.

Totally agree with that. Still, I think it's an option that some people might find appealing. 1st year comp is averaging $225-275k at the big firms in NY, but some people might find the 80-100 hours week after week too much. People might find 60-80 hours a week more manageable, earning$175-200k 1st year in LA or SF, with an outside shot of making as much as the people in NY. Factor in a lower cost of living (everywhere costs less than NY, even SF) and things start to look a little different. Also, don't forget that if you want to live it up with a condo in NY, you'll have to pay city income tax, on top of state and federal (learned that one the hard way).

$175k to start in LA or SF and leaving most days while the sun is still out (in the summer months at least) might be a pretty nice option for those that want to get paid (or is that pay'd) but aren't willing to forfeit their lives completely to the grind. There is no doubt that you'll be missing out on the big deals if you aren't in NY; heck that's the reason I moved from LA to NY as a lawyer - to do the big deals. Personally, I'm over that silliness, but everyone needs to find out for themselves, and I support the idea that everyone should at least spend some time working in NY if they can. There is also another option - for those willing to give up a little prestige to have a little better quality of life. Some middle market firms are doing brisk business these days and paying almost as well as the glamorous big names, at least in the early years. I think there's less of a sense that you need to sell your soul to these firms when you work there, but of course you're not going to impress the maitre'd or make the cover of Barron's (so to speak). Here's a link to the Vault.com summary for Houlihan Lokey: http://www.vault.com/eprints/HoulihanLokey2006.pdf So if you want it all, the big bucks, big nameplate, big deals and big recognition, you'll have to join one of the big-name Ibanks. If you're willing to give up a little cash or prestige or access, I think there are reasonable alternatives for careers in finance (in addition to the corporate finance roles already discussed). Director Joined: 07 Aug 2006 Posts: 572 Followers: 1 Kudos [?]: 5 [0], given: 0 [#permalink] 12 Apr 2007, 05:14 I've heard good things about Houlihan Lokey. I've also heard that Lehman is a little better than some of the other big name players. Manager Joined: 16 Nov 2005 Posts: 74 Location: Newark, DE Followers: 1 Kudos [?]: 1 [0], given: 0 [#permalink] 12 Apr 2007, 08:07 Can anyone confirm the LA vs. NY difference? That sounds optimal for me. I could work 70-80 rather than 80-100 if I got paid$150k-175k.

Also do the hours still revolve around NYC in the LA Finance industry? I.e. get to work at 5 a.m. before Wall Street opens?
VP
Joined: 11 Dec 2006
Posts: 1429
Location: New York, NY
Schools: NYU Stern 2009
Followers: 41

Kudos [?]: 219 [0], given: 6

Not in IB I wouldn't expect, unless on special occassions (dawn raids perhaps).

I really do think there is a risk that, although it meets short term aims, being in one of the IB offices outside the main has risks. Promotion is slower, and cut-backs are more savage. Irrespective of what you do, being under the big guys nose in head office helps.

"Equities in Denver" was considered a bad thing with good reason.
SVP
Joined: 31 Jul 2006
Posts: 2304
Schools: Darden
Followers: 42

Kudos [?]: 451 [0], given: 0

If you work as a trader, you'll need to be in the office during market hours. I knew some people with Bear Stearns sales & trading in LA that got into the office at 4:30AM and left around 3PM, M-F. For other functions, you get into work at a normal hour (around 9-9:30AM I guess), and you take off a couple of hours earlier each day compared to NY. You definitely work fewer weekends too. This is a vast generalization of course and each person's experience will differ.

For those that want to build a career in IB, NY is the only place to be. For those that want to work in IB for 2-6 years and then move on, a branch office is a reasonable alternative. Of course, the further you get from the action, the tougher it will be move ahead. NY is best, and Chicago, SF & LA are next. When you start talking about Houston, Denver, Cleveland etc., the chances of making a career out of it are slim. But from what I can tell, not many people here are planning 20 year careers in IB.
Current Student
Joined: 04 Dec 2006
Posts: 440
Followers: 1

Kudos [?]: 6 [0], given: 0

pelihu wrote:
For those that want to build a career in IB, NY is the only place to be. For those that want to work in IB for 2-6 years and then move on, a branch office is a reasonable alternative. Of course, the further you get from the action, the tougher it will be move ahead. NY is best, and Chicago, SF & LA are next. When you start talking about Houston, Denver, Cleveland etc., the chances of making a career out of it are slim. But from what I can tell, not many people here are planning 20 year careers in IB.

This information is good to know. If I could do 60-70 hour weeks in IB for 5-6 years in Houston or Cali I would be happy. For me, if I worked in IB it would not be to establish a career, rather make some  and have it on my resume. Plus 4:30-3 are stellar hours, yes you are up a little early, but you get out at 3 everyday, hit the gym, take a nap and hit happy hour!

Go to page    1   2    Next  [ 35 posts ]

Similar topics Replies Last post
Similar
Topics:
Asia Finance Career - MBA Location 0 09 Nov 2012, 06:30
39 Family + Post-MBA Career = Oil + Water 83 17 Aug 2008, 18:53
Post MBA Career Choices Video 1 31 Jan 2008, 06:23
What is your post MBA Career 17 31 Aug 2007, 09:59
Post-MBA career switch 1 20 Nov 2006, 09:28
Display posts from previous: Sort by