Tim Booher

First I read the docs at: rubydoc.info to understand how FasterCSV is now in the ruby standard library.

Then, I set up the following code:

https://gist.github.com/tbbooher/1700200

This gives me a pretty flexible solution to render csv, but I’m really interested to see if this is a good way to go. Your comments are appreciated.

[mathjax]

Here we tackle what a Radar needs to accurately measure a target’s position, size and motion. (This is nothing new, just a placeholder for some of my notes.)

First of all, everything depends on $SNR$, and the parameter estimation happens in the main computer of a Radar. The theoretical rms error of a measurement is of the form:

where \(k\) is a constant between 0.5 and 1.

h3. Range

First, let’s tackle range. They key metric for range is bandwidth, the higher the bandwidth the better the resolution.

Estimation of the range of a target is based upon using A/D sampled measurements of the round trip time to and the target

For time delay measurements , such as range, the value of the constant depends on the shape of the radar pulse’s spectrum and the pulse’s rise time and for a rectangular pulse, whose width is, (T):

or equivalently,

However, pulses always move in trains or if $T_D$ is the dwell time:

from Barton and Ward.

So Range depends on \(SNR\), pulse shape and width, effective bandwidth, number of pulses that can be coherently integrated.

This is explained well by a diagram in the lincoln presentation:

h3. Angle

Now, let’s tackle angle. Angle accuracy depends on antenna size. Simple detection provides coarse location in angle by isolating a target’s location within beamwidth of antenna (and beamwidth is just \(\lambda / D \), where \(D\) is the aperture diameter and \(\lambda \) is the wavelength. But this is very coarse, 1° beam at 100 km extends across 1,745 meters. In order to provide more accurate angle estimation, you have to measure at different beam positions to improve accuracy. You can do this through sequential lobing, conical scan tracking, or monopulse angle estimation.

h4. Conical Scanning

Conical scanning is a technique to keep the beam pointed at the target to improve angle accuracy. It is based on the principle that the radar receiver will get maximum returned signal strength when the target is in the beam centre, so if the beam is pointed directly at the target, when the target moves it will move out of the beam center and the received signal strength will fall. Circuitry designed to monitor any fall off in received signal strength controls a servo motor that steers the aerial to follow the target motion.

Wikipedia has a nice drawing that explains this technique:

!https://upload.wikimedia.org/wikipedia/commons/3/32/Conical_scan.jpg!

h4. Sequential lobing

While conical scan tracking uses the phase of modulation to get the angle error and amplitude modulation to get the beam displacement, sequential lobing uses two slightly separated antenna elements to send the beam slightly to either side of the midline of the antenna, switching between the two to find which one gave the stronger return, thereby indicating which direction the antenna should be moved in order to point directly at the target.

Here, wikipedia provides another good diagram:

!https://upload.wikimedia.org/wikipedia/commons/b/b6/Monopulseprinzip2.gif!

h4. Monopulse

Monopulse radars are similar in general construction to conical scanning systems, but add one more feature. Instead of broadcasting the signal out of the antenna “as is”, they split the beam into parts and then send the two signals out of the antenna in slightly different directions. When the reflected signals are received they are amplified separately and compared to each other, indicating which direction has a stronger return, and thus the general direction of the target relative to the boresight. While monopulse, requires a separate receiver for each channel, it improves performance over conical scan and sequential lobing whose performance degrade with time varying radar returns.

All angle errors are summed up well by the following:

and

SNR, type of measurement technique, antenna illumination distribution, antenna size, and frequency.

h3. Doppler

Lastly, let’s look at Doppler accuracy. Doppler accuracy depends on coherent integration time \(\Delta t \):

Doppler frequency is calculated as:

To accurately measure Doppler, use two closely spaced frequency filters offset from the center frequency of the Doppler filter containing the detection

Doppler accuracy depends on SNR, pulse shape, integration time.

h3. Real world limitations

h4. Receiver noise

# Adds variance to estimates

h4. Radar calibration

# Poor calibration leads to poor estimation

h4. Amplitude fluctuations

# Small effect on monopulse and array solutions

h4. Angle noise (angle scintillations, or target glint)

# Complex target return biases angle estimate

h4. Multipath (low angle tracking)

# Reflection off earth’s surface combines with direct path return

# Can cause biases in angle estimates for all technique

h4. Good References

“Parameter Estimation”:http://www.ll.mit.edu/workshops/education/videocourses/introradar/lecture9/lecture.pdf

“Basic Fundamentals”:http://faculty.nps.edu/jenn/Seminars/RadarFundamentals.pdf

“Parameter Estimation and Tracking”:http://aess.cs.unh.edu/Radar{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}202010{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}20PDFs/Radar{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}202009{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}20A_15{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}20Parameter{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}20Estimation{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}20and{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}20Tracking{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}20Part{aaa01f1184b23bc5204459599a780c2efd1a71f819cd2b338cab4b7a2f8e97d4}201.pdf

[
E = frac{eta}{c}left( frac{C_L^{3/2}}{C_D} right) sqrt{2 rho S} left( frac{1}{W_f} – frac{1}{W_i} right)
]

Where (eta) is the propeller efficiency, (c) is the minimum power specific fuel consumption rate, maximum density of air, ( rho ).

In one of my applications, I have the following config files that are excluded from git:

* config/mongoid.yml
* config/application.yml
* config/mailserver_setting.rb
* config/omniauth_settings.rb

For deploying to a regular server, I just add tasks to my capistrano deployment file to create sym-links to a shared directory. In this case I have to modify my application to use local ENV files and consequently the ENV hash in my rails app.

In my configuration.rb (boots at initialization):

config_file =  File.expand_path('../../config/application.yml', __FILE__)
if File.exist?(config_file)
  APPLICATION_CONFIG=YAML.load_file(config_file)[Rails.env]['application']
  CONSTANTS=YAML.load_file(config_file)[Rails.env]['constants']
  APPLICATION_CONFIG.each{|k,v| ENV["APPLICATION_CONFIG_#{k}"] = v.to_s }
  CONSTANTS.each{|k,v| ENV["CONSTANTS_#{k}"] = v.to_s}
end

So using the following custom thor task, I can load heroku’s env files based on some code from Les Hill:

This works well.

If I have two Mongoid models joined by a has_and_belongs_to_many relationship, Users and Groups. I need to quickly and efficiently sort by the most popular groups which really should be done with a counter_cache. However, counter_caches are implemented in rails by setting a callback to update the counter cache every time a child model is created/destroyed. But, Mongoid does not present callbacks for HABTM, and there are no real records that are getting created anyway. Additionally, you can add a whole collection of associations at once which would not be compatible with the efficient Mongoid inc operator. There is a mongoid_counter_cache gem that I played with for awhile, but for these reasons, I couldn’t get it to work with my existing schema, so I had to roll my own solution to this.

To complicate things, a user can follow a group or join a group. Following a group just keeps them informed on what the group is doing, joining allows them to participate. To make all this work, I have the following associations defined:

bc.
include Mongoid::Document
field :name, :type => String
field :type, :type => Symbol, :default => :custom
field :description, :type => String
index :name
index :type
field :follower_count
field :member_count

belongs_to :owner, :class_name => “User”, :inverse_of => :custom_groups

has_and_belongs_to_many :members, :class_name => “User”, :inverse_of => :joined_groups
has_and_belongs_to_many :followers, :class_name => “User”, :inverse_of => :followed_groups

And for the user:

bc.
has_and_belongs_to_many :joined_groups, :class_name => “PolcoGroup”, :inverse_of => :members
has_and_belongs_to_many :followed_groups, :class_name => “PolcoGroup”, :inverse_of => :followers

I’m sticking with the _count naming convention in case, I get some performance boost when calling parent.children.size which will read the cached value instead of actually querying the database. The column type is integer and we also pass a :default => 0.

Since I can’t use Mongoid’s atomic update here, I’m going to go through the database and update the relevant field with the current count.

bq.
after_save :update_categories_counter_cache
def update_categories_counter_cache
self.categories.each { |c| c.update_count(self) } unless self.categories.empty?
end

What does all this mean? We are adding an after_save callback method called update_categories_counter_cache. This metod is triggered after the record is saved, and it loops through all categories (if self.categories array is not empty, that is) and calls update_count method for each of them. The update_count is defined in Category model file (well, not yet, but you will define it now). The reason for the loop is that you might have multiple assignments on one save, so we make sure all categories that the post belongs to are updated.

Let’s define the update_count method for the Category model. Open category.rb and add the follwing:

def update_count
update_attribute(:posts_count, self.posts.length)
end