occupancy_handlers.h

Go to the documentation of this file.

// Copyright (c) 2009-2010  INRIA Sophia-Antipolis (France).
// All rights reserved.
//
//This file is part of ESBTL.
//
//ESBTL is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//ESBTL is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with ESBTL.  If not, see <http://www.gnu.org/licenses/>.
//
//
//Additional permission under GNU GPL version 3 section 7
//
//If you modify this Library, or any covered work, by linking or
//combining it with CGAL (or a modified version of that library), the
//licensors of this Library grant you additional permission to convey
//the resulting work. Corresponding Source for a non-source form of
//such a combination shall include the source code for the parts of CGAL
//used as well as that of the covered work. 
//
//
//
// Author(s)     :  Sébastien Loriot



#ifndef ESBTL_OCCUPANCY_HANDLERS_H
#define ESBTL_OCCUPANCY_HANDLERS_H

#include <set>
#include <iostream>

namespace ESBTL{

  template <class Line_format>
  struct No_occupancy_policy{
    int add_or_postpone(const Line_format& line_format,const std::string& line,int system_index) const{
      double occupancy_value=line_format.get_occupancy(line);
      if (occupancy_value==1. || line_format.get_alternate_location(line)!=' ')
        return system_index;
      std::cerr << "Fatal error: Occupancy factor < 1. No occupancy selection policy is provided to handle line\n";
      std::cerr << "<|" << line << "|>\n";
      exit(EXIT_FAILURE);
    }
    
    template <class Builder>
    int finalize(Builder&) const {return 0;}
  };


  template <class Line_format>
  struct Accept_all_occupancy_policy{
    int add_or_postpone(const Line_format& ,const std::string& ,int system_index) const {
      return system_index;
    }
    
    template <class Builder>
    int finalize(Builder&) const {return 0;}
  };

  template <class Line_format>
  struct Accept_none_occupancy_policy{
    int add_or_postpone(const Line_format& line_format,const std::string& line,int system_index) const {
      double occupancy_value=line_format.get_occupancy(line);
      if (occupancy_value==1. || line_format.get_alternate_location(line)!=' ')
        return system_index;      
      return DISCARD;
    }
    
    template <class Builder>
    int finalize(Builder&) const {return 0;}
  };

  namespace internal{
    
    template <class Line_format,bool take_max>
    class Min_or_max_occupancy_policy{
    protected:
      typedef std::map<double,std::pair<int,std::list<std::string> > > Info;
      Info lines;
      double min_or_max_occupancy;
      
      Min_or_max_occupancy_policy():min_or_max_occupancy(take_max?0.:1.){}
      
      void add_line(double occupancy_value,const std::string& line,int system_index){
        typename Info::iterator it=lines.find(occupancy_value);
        if (it==lines.end())
          it=lines.insert(
              std::make_pair(occupancy_value,
                             std::make_pair(system_index,std::list<std::string>())) 
          ).first;
        it->second.second.push_back(line);
      }
      
    public:
      int add_or_postpone(const Line_format& line_format,const std::string& line,int system_index){
        double occupancy_value=line_format.get_occupancy(line);
        if (occupancy_value==1. || line_format.get_alternate_location(line)!=' ')
          return system_index;
        
        bool do_take_it=take_max?
                          occupancy_value >= min_or_max_occupancy:
                          occupancy_value <= min_or_max_occupancy;
          
        if (do_take_it){
          add_line(occupancy_value,line,system_index);
          min_or_max_occupancy=occupancy_value;
        }
        
        return DISCARD;
      }
      
      template <class Builder>
      int finalize(Builder& builder) const {
        if (lines.empty())
          return 0;
        if (min_or_max_occupancy==0.5){
          std::cerr << "Fatal error: The atom occupancy selection policy is ambiguous is that case (0.5)\n";
          exit(EXIT_FAILURE);
        }
        int lines_added=0;
        Info::const_iterator it=lines.find(min_or_max_occupancy);
        for (std::list<std::string>::const_iterator cur=it->second.second.begin();
             cur!=it->second.second.end(); ++cur)
        {
          ++lines_added;
          builder.interpret_line(Line_format(*cur),*cur,it->second.first);
        }
        
        return lines_added;
      }
    };
    
  }//namespace internal
  template<class Line_format>
  class Max_occupancy_policy: public internal::Min_or_max_occupancy_policy<Line_format,true>{};


  template<class Line_format>
  class Min_occupancy_policy: public internal::Min_or_max_occupancy_policy<Line_format,false>{};
  
  template <class Line_format>
  class Atom_list_occupancy_policy{
    std::set<int> selected_atoms;
  public:  
    template <class Iterator>
    Atom_list_occupancy_policy(Iterator begin,Iterator end){
      selected_atoms.insert(begin,end);
    }
  
    int add_or_postpone(const Line_format& line_format,const std::string& line,int system_index) const {
      double occupancy_value=line_format.get_occupancy(line);
      if (occupancy_value==1. || line_format.get_alternate_location(line)!=' ')
        return system_index;
      
      if (selected_atoms.find(line_format.get_atom_serial_number(line))!=selected_atoms.end())
        return system_index;
      
      return DISCARD;
    }
    
    template <class Builder>
    int finalize(Builder&) const {
      return 0;
    }
  };
} //namespace ESBTL


#endif //ESBTL_OCCUPANCY_HANDLERS_H