EMAN::EvenOrientationGenerator Class Reference

Sparx even orientation generator - see util_sparx.cpp - Util::even_angles(. More...

#include <symmetry.h>

Inheritance diagram for EMAN::EvenOrientationGenerator:

Inheritance graph
[legend]
Collaboration diagram for EMAN::EvenOrientationGenerator:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 EvenOrientationGenerator ()
virtual ~EvenOrientationGenerator ()
virtual string get_name () const
 Return "even".
virtual string get_desc () const
 Get a description.
virtual TypeDict get_param_types () const
 Get a dictionary containing the permissable parameters of this class.
virtual vector< Transformgen_orientations (const Symmetry3D *const sym) const
 Generate even distributed orientations in the asymmetric unit of the symmetry.

Static Public Member Functions

static OrientationGeneratorNEW ()
 Factory support function NEW.

Static Public Attributes

static const string NAME = "even"
 The name of this class - used to access it from factories etc. Should be "icos".

Private Member Functions

 EvenOrientationGenerator (const EvenOrientationGenerator &)
 Disallow copy construction.
EvenOrientationGeneratoroperator= (const EvenOrientationGenerator &)
 Disallow assignment.
virtual int get_orientations_tally (const Symmetry3D *const sym, const float &delta) const
 This function returns how many orientations will be generated for a given delta (angular spacing) It does this by simulated gen_orientations.

Detailed Description

Sparx even orientation generator - see util_sparx.cpp - Util::even_angles(.

..) This orientation generator is based on work presented in Penczek et al., 1994 P.A. Penczek, R.A. Grassucci and J. Frank, The ribosome at improved resolution: new techniques for merging and orientation refinement in 3D cryo-electron microscopy of biological particles, Ultramicroscopy 53 (1994).

This is a proportional approach very similar to the eman approach - the differences between these two approaches is mostly visible near altitude=0

Author:
David Woolford (ported directly from Sparx utilities.py, which is written by Pawel Penczek)
Date:
March 2008

Definition at line 1230 of file symmetry.h.


Constructor & Destructor Documentation

EMAN::EvenOrientationGenerator::EvenOrientationGenerator (  )  [inline]

Definition at line 1233 of file symmetry.h.

Referenced by NEW().

01233 {}

virtual EMAN::EvenOrientationGenerator::~EvenOrientationGenerator (  )  [inline, virtual]

Definition at line 1234 of file symmetry.h.

01234 {}

EMAN::EvenOrientationGenerator::EvenOrientationGenerator ( const EvenOrientationGenerator  )  [private]

Disallow copy construction.


Member Function Documentation

vector< Transform > EvenOrientationGenerator::gen_orientations ( const Symmetry3D *const   sym  )  const [virtual]

Generate even distributed orientations in the asymmetric unit of the symmetry.

Parameters:
sym the symmetry which defines the interesting asymmetric unit
Returns:
a vector of Transform objects containing the set of evenly distributed orientations

Implements EMAN::OrientationGenerator.

Definition at line 598 of file symmetry.cpp.

References EMAN::OrientationGenerator::add_orientation(), EMAN::EMConsts::deg2rad, EMAN::Symmetry3D::get_az_alignment_offset(), EMAN::Symmetry3D::get_delimiters(), EMAN::OrientationGenerator::get_optimal_delta(), InvalidParameterException, EMAN::Symmetry3D::is_h_sym(), EMAN::Symmetry3D::is_in_asym_unit(), EMAN::Symmetry3D::is_platonic_sym(), EMAN::FactoryBase::params, and EMAN::Dict::set_default().

00599 {
00600         float delta = params.set_default("delta", 0.0f);
00601         int n = params.set_default("n", 0);
00602 
00603         if ( delta <= 0 && n <= 0 ) throw InvalidParameterException("Error, you must specify a positive non-zero delta or n");
00604         if ( delta > 0 && n > 0 ) throw InvalidParameterException("Error, the delta and the n arguments are mutually exzclusive");
00605 
00606         if ( n > 0 ) {
00607                 delta = get_optimal_delta(sym,n);
00608         }
00609 
00610         bool inc_mirror = params.set_default("inc_mirror",false);
00611         Dict delimiters = sym->get_delimiters(inc_mirror);
00612         float altmax = delimiters["alt_max"];
00613         float azmax = delimiters["az_max"];
00614 
00615         float altmin = 0.0f;
00616         // If it's a h symmetry then the alt iterator starts at very close
00617         // to the altmax... the object is a h symmetry then it knows its alt_min...
00618         if (sym->is_h_sym()) altmin = delimiters["alt_min"];
00619 
00620         vector<Transform> ret;
00621 
00622         for (float alt = altmin; alt <= altmax; alt += delta) {
00623                 float detaz;
00624                 int lt;
00625                 if ((0.0f == alt)||(180.0f == alt)) {
00626                         detaz = 360.0f;
00627                         lt = 1;
00628                 } else {
00629                         detaz = delta/(float)sin(alt*EMConsts::deg2rad);
00630                         lt = int(azmax/detaz)-1;
00631                         if (lt < 1) lt = 1;
00632                         detaz = azmax/(float)lt;
00633                 }
00634 //              bool d_odd_mirror_flag = false;
00635 //              get_az_max(sym,altmax, inc_mirror,alt, lt,d_odd_mirror_flag, detaz);
00636 
00637                 for (int i = 0; i < lt; i++) {
00638                         float az = (float)i*detaz;
00639                         if (sym->is_platonic_sym()) {
00640                                 if ( sym->is_in_asym_unit(alt, az,inc_mirror) == false ) continue;
00641                                 else {
00642                                         az += sym->get_az_alignment_offset(); // Align to the symmetry axes
00643                                 }
00644                         }
00645                         add_orientation(ret,az,alt);
00646                         if ( sym->is_h_sym() && inc_mirror && alt != altmin ) {
00647                                 add_orientation(ret,az,2.0f*altmin-alt);
00648                         }
00649                 }
00650         }
00651 
00652         return ret;
00653 }

virtual string EMAN::EvenOrientationGenerator::get_desc (  )  const [inline, virtual]

Get a description.

Returns:
a clear desciption of this class

Implements EMAN::FactoryBase.

Definition at line 1253 of file symmetry.h.

01253 { return "Generate quasi-evenly distributed orientations within an asymmetric unit using Penczek's (94) approach"; }

virtual string EMAN::EvenOrientationGenerator::get_name (  )  const [inline, virtual]

Return "even".

Returns:
the unique name of this class

Implements EMAN::FactoryBase.

Definition at line 1248 of file symmetry.h.

References NAME.

01248 { return NAME; }

int EvenOrientationGenerator::get_orientations_tally ( const Symmetry3D *const   sym,
const float &  delta 
) const [private, virtual]

This function returns how many orientations will be generated for a given delta (angular spacing) It does this by simulated gen_orientations.

Parameters:
sym the symmetry which defines the interesting asymmetric unit
delta the desired angular spacing of the orientations
Returns:
the number of orientations that will be generated using these parameters

Implements EMAN::OrientationGenerator.

Definition at line 555 of file symmetry.cpp.

References EMAN::EMConsts::deg2rad, EMAN::Symmetry3D::get_delimiters(), EMAN::Symmetry3D::is_h_sym(), EMAN::Symmetry3D::is_in_asym_unit(), EMAN::Symmetry3D::is_platonic_sym(), EMAN::FactoryBase::params, and EMAN::Dict::set_default().

00556 {
00557         bool inc_mirror = params.set_default("inc_mirror",false);
00558         Dict delimiters = sym->get_delimiters(inc_mirror);
00559         float altmax = delimiters["alt_max"];
00560         float azmax = delimiters["az_max"];
00561 
00562         float altmin = 0.0f;
00563         // #If it's a h symmetry then the alt iterator starts at very close
00564         // #to the altmax... the object is a h symmetry then it knows its alt_min...
00565         if (sym->is_h_sym()) altmin = delimiters["alt_min"];
00566 
00567         int tally = 0;
00568 
00569         for (float alt = altmin; alt <= altmax; alt += delta) {
00570                 float detaz;
00571                 int lt;
00572                 if ((0.0f == alt)||(180.0f == alt)) {
00573                         detaz = 360.0f;
00574                         lt = 1;
00575                 } else {
00576                         detaz = delta/(float)sin(alt*EMConsts::deg2rad);
00577                         lt = int(azmax/detaz)-1;
00578                         if (lt < 1) lt = 1;
00579                         detaz = azmax/(float)lt;
00580                 }
00581 //              bool d_odd_mirror_flag = false;
00582 //              get_az_max(sym,altmax, inc_mirror,alt, lt,d_odd_mirror_flag, detaz);
00583                 for (int i = 0; i < lt; i++) {
00584                         float az = (float)i*detaz;
00585                         if (sym->is_platonic_sym()) {
00586                                 if ( sym->is_in_asym_unit(alt, az,inc_mirror) == false ) continue;
00587                         }
00588                         tally++;
00589                         if ( sym->is_h_sym() && inc_mirror && alt != altmin ) {
00590                                 tally++;
00591                         }
00592                 }
00593         }
00594 
00595         return tally;
00596 }

virtual TypeDict EMAN::EvenOrientationGenerator::get_param_types (  )  const [inline, virtual]

Get a dictionary containing the permissable parameters of this class.

Returns:
a dictionary containing the permissable parameters of this class parameters are explained in the dictionary itself

Reimplemented from EMAN::OrientationGenerator.

Definition at line 1259 of file symmetry.h.

References EMAN::EMObject::BOOL, EMAN::EMObject::FLOAT, EMAN::OrientationGenerator::get_param_types(), EMAN::EMObject::INT, and EMAN::TypeDict::put().

01260                 {
01261                         TypeDict d = OrientationGenerator::get_param_types();
01262                         d.put("delta", EMObject::FLOAT, "The angular separation of orientations in degrees. This option is mutually exclusively of the n argument.");
01263                         d.put("inc_mirror", EMObject::BOOL, "Indicates whether or not to include the mirror portion of the asymmetric unit. Default is false.");
01264                         d.put("n", EMObject::INT, "The number of orientations to generate. This option is mutually exclusively of the delta argument.Will attempt to get as close to the number specified as possible.");
01265                         return d;
01266                 }

static OrientationGenerator* EMAN::EvenOrientationGenerator::NEW (  )  [inline, static]

Factory support function NEW.

Returns:
a newly instantiated class of this type

Definition at line 1239 of file symmetry.h.

References EvenOrientationGenerator().

01240                 {
01241                         return new EvenOrientationGenerator();
01242                 }

EvenOrientationGenerator& EMAN::EvenOrientationGenerator::operator= ( const EvenOrientationGenerator  )  [private]

Disallow assignment.


Member Data Documentation

const string EvenOrientationGenerator::NAME = "even" [static]

The name of this class - used to access it from factories etc. Should be "icos".

Definition at line 1275 of file symmetry.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Tue Jun 11 12:45:31 2013 for EMAN2 by  doxygen 1.4.7