Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

EMAN::EvenOrientationGenerator Class Reference

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. 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

OrientationGeneratorNEW ()
 Factory support function NEW.

Static Public Attributes

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.

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::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(), 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.

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::Symmetry3D::get_delimiters(), EMAN::Symmetry3D::is_h_sym(), EMAN::Symmetry3D::is_in_asym_unit(), EMAN::Symmetry3D::is_platonic_sym(), 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::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                 }

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.

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 49 of file symmetry.cpp.


The documentation for this class was generated from the following files:
Generated on Tue Jun 11 13:49:48 2013 for EMAN2 by  doxygen 1.3.9.1