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 1165 of file symmetry.h.


Constructor & Destructor Documentation

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

Definition at line 1168 of file symmetry.h.

Referenced by NEW().

01168 {}

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

Definition at line 1169 of file symmetry.h.

01169 {}

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 592 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().

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

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 1188 of file symmetry.h.

01188 { 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 1183 of file symmetry.h.

References NAME.

01183 { 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 549 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().

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

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 1194 of file symmetry.h.

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

01195                 {
01196                         TypeDict d = OrientationGenerator::get_param_types();
01197                         d.put("delta", EMObject::FLOAT, "The angular separation of orientations in degrees. This option is mutually exclusively of the n argument.");
01198                         d.put("inc_mirror", EMObject::BOOL, "Indicates whether or not to include the mirror portion of the asymmetric unit. Default is false.");
01199                         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.");
01200                         return d;
01201                 }

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

Factory support function NEW.

Returns:
a newly instantiated class of this type

Definition at line 1174 of file symmetry.h.

References EvenOrientationGenerator().

01175                 {
01176                         return new EvenOrientationGenerator();
01177                 }

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 1210 of file symmetry.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Thu Nov 17 12:47:43 2011 for EMAN2 by  doxygen 1.4.7