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

EMAN::SaffOrientationGenerator Class Reference

Saff orientation generator - based on the work of Saff and Kuijlaars, 1997 E.B. More...

#include <symmetry.h>

Inheritance diagram for EMAN::SaffOrientationGenerator:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

 SaffOrientationGenerator ()
virtual ~SaffOrientationGenerator ()
virtual string get_name () const
 Return "saff".
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 Saff orientations in the asymmetric unit of the symmetry.

Static Public Member Functions

OrientationGeneratorNEW ()
 Factory support function NEW.

Static Public Attributes

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

Private Member Functions

 SaffOrientationGenerator (const SaffOrientationGenerator &)
 Disallow copy construction.
SaffOrientationGeneratoroperator= (const SaffOrientationGenerator &)
 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

Saff orientation generator - based on the work of Saff and Kuijlaars, 1997 E.B.

Saff and A.B.J. Kuijlaars, Distributing many points on a sphere, Mathematical Intelligencer 19 (1997), pp. 5–11. This is a spiral based approach

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

Definition at line 1231 of file symmetry.h.


Constructor & Destructor Documentation

EMAN::SaffOrientationGenerator::SaffOrientationGenerator  )  [inline]
 

Definition at line 1234 of file symmetry.h.

01234 {}

virtual EMAN::SaffOrientationGenerator::~SaffOrientationGenerator  )  [inline, virtual]
 

Definition at line 1235 of file symmetry.h.

01235 {}

EMAN::SaffOrientationGenerator::SaffOrientationGenerator const SaffOrientationGenerator  )  [private]
 

Disallow copy construction.


Member Function Documentation

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

Generate Saff 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 690 of file symmetry.cpp.

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

00691 {
00692         float delta = params.set_default("delta", 0.0f);
00693         int n = params.set_default("n", 0);
00694 
00695         if ( delta <= 0 && n <= 0 ) throw InvalidParameterException("Error, you must specify a positive non-zero delta or n");
00696         if ( delta > 0 && n > 0 ) throw InvalidParameterException("Error, the delta and the n arguments are mutually exclusive");
00697 
00698         if ( n > 0 ) {
00699                 delta = get_optimal_delta(sym,n);
00700         }
00701 
00702 //      if ( sym->is_platonic_sym() ) return gen_platonic_orientations(sym, delta);
00703 
00704         bool inc_mirror = params.set_default("inc_mirror",false);
00705         Dict delimiters = sym->get_delimiters(inc_mirror);
00706         float altmax = delimiters["alt_max"];
00707         float azmax = delimiters["az_max"];
00708 
00709         float altmin = 0.0f;
00710         // #If it's a h symmetry then the alt iterator starts at very close
00711         // #to the altmax... the object is a h symmetry then it knows its alt_min...
00712         if (sym->is_h_sym()){
00713                 altmin = delimiters["alt_min"];
00714                 if (inc_mirror) {
00715                         altmin -= (float) sym->get_params()["maxtilt"];
00716                 }
00717         }
00718 
00719         float Deltaz = (float)(cos(altmax*EMConsts::deg2rad)-cos(altmin*EMConsts::deg2rad));
00720         float s = delta*M_PI/180.0f;
00721         float NFactor = 3.6f/s;
00722         float wedgeFactor = fabs( Deltaz*(azmax)/720.0f) ;
00723         int NumPoints   =  static_cast<int> (NFactor*NFactor*wedgeFactor);
00724 
00725         vector<Transform> ret;
00726 
00727         if (!sym->is_h_sym()) add_orientation(ret,0,0);
00728         float az = 0.0f;
00729         float dz = (float)cos(altmin*EMConsts::deg2rad);
00730         for(int i = 1; i < NumPoints; ++i ){
00731                 float z = dz + Deltaz* (float)i/ float(NumPoints-1);
00732                 float r= sqrt(1.0f-z*z);
00733                 az = fmod(az + delta/r,azmax);
00734                 float alt = (float)(acos(z)*EMConsts::rad2deg);
00735                 if (sym->is_platonic_sym()) {
00736                         if ( sym->is_in_asym_unit(alt,az,inc_mirror) == false ) continue;
00737                         else {
00738                                 az += sym->get_az_alignment_offset(); // Align to the symmetry axes
00739                         }
00740                 }
00741                 add_orientation(ret,az,alt);
00742         }
00743 
00744         return ret;
00745 }

virtual string EMAN::SaffOrientationGenerator::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 a spiraling method attributed to Saff"; }

virtual string EMAN::SaffOrientationGenerator::get_name  )  const [inline, virtual]
 

Return "saff".

Returns:
the unique name of this class

Implements EMAN::FactoryBase.

Definition at line 1248 of file symmetry.h.

01248 { return NAME; }

int SaffOrientationGenerator::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 649 of file symmetry.cpp.

References EMAN::Symmetry3D::get_delimiters(), EMAN::FactoryBase::get_params(), EMAN::Symmetry3D::is_h_sym(), EMAN::Symmetry3D::is_in_asym_unit(), EMAN::Symmetry3D::is_platonic_sym(), EMAN::Dict::set_default(), and sqrt().

00650 {
00651         bool inc_mirror = params.set_default("inc_mirror",false);
00652         Dict delimiters = sym->get_delimiters(inc_mirror);
00653         float altmax = delimiters["alt_max"];
00654         float azmax = delimiters["az_max"];
00655 
00656         float altmin = 0.0f;
00657         // #If it's a h symmetry then the alt iterator starts at very close
00658         // #to the altmax... the object is a h symmetry then it knows its alt_min...
00659         if (sym->is_h_sym()){
00660                 altmin = delimiters["alt_min"];
00661                 if (inc_mirror) {
00662                         altmin -= (float) sym->get_params()["maxtilt"];
00663                 }
00664         }
00665 
00666         float Deltaz = (float)(cos(altmax*EMConsts::deg2rad)-cos(altmin*EMConsts::deg2rad));
00667         float s = delta*M_PI/180.0f;
00668         float NFactor = 3.6f/s;
00669         float wedgeFactor = fabs( Deltaz*(azmax)/720.0f) ;
00670         int NumPoints   =  static_cast<int> (NFactor*NFactor*wedgeFactor);
00671 
00672         int tally = 0;
00673         if (!sym->is_h_sym()) ++tally;
00674         float az = 0.0f;
00675         float dz = (float)cos(altmin*EMConsts::deg2rad);
00676         for(int i = 1; i < NumPoints; ++i ){
00677                 float z = dz + Deltaz* (float)i/ float(NumPoints-1);
00678                 float r= sqrt(1.0f-z*z);
00679                 az = fmod(az + delta/r,azmax);
00680                 float alt = (float)(acos(z)*EMConsts::rad2deg);
00681                 if (sym->is_platonic_sym()) {
00682                         if ( sym->is_in_asym_unit(alt,az,inc_mirror) == false ) continue;
00683                 }
00684                 tally++;
00685         }
00686 
00687         return tally;
00688 }

virtual TypeDict EMAN::SaffOrientationGenerator::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("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.");
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("delta", EMObject::FLOAT, "The angular separation of orientations in degrees. This option is mutually exclusively of the n argument.");
01265                         return d;
01266                 }

OrientationGenerator* EMAN::SaffOrientationGenerator::NEW  )  [inline, static]
 

Factory support function NEW.

Returns:
a newly instantiated class of this type

Definition at line 1240 of file symmetry.h.

01241                 {
01242                         return new SaffOrientationGenerator();
01243                 }

SaffOrientationGenerator& EMAN::SaffOrientationGenerator::operator= const SaffOrientationGenerator  )  [private]
 

Disallow assignment.


Member Data Documentation

const string SaffOrientationGenerator::NAME = "saff" [static]
 

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

Definition at line 47 of file symmetry.cpp.


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