// FeatureRange.h
// Thu Aug 13 14:55:18 PDT 2009 Kevin Karplus

// This file contains the definition of the FeatureRangeAlphabet class;
// This is derived from the alphabet class, but supports additional
// name/value pairs for describing alphabets that divide up a
//	ResidueFeature into ranges
//


#ifndef FEATURERANGEALPHABET
#define FEATURERANGEALPHABET

#include <string>
#include <math.h>	// for floor

#include "Alphabet/Alphabet.h"

class ChainsResiduesAndAtoms;
class Conformation;
class ResidueFeature;

// To make sure that FeatureRangeAlphabet is linked in,
// call FeatureRangeAlphabet::classID() somewhere in a program.

class FeatureRangeAlphabet : public Alphabet {
    private:
    
    // required stuff for things derived from NamedClass
	static IdObject ID;
	
	static void init_is_a(IdObject *self)
	{    self->add_is_a(Alphabet::classID());
	}

	virtual int read_knowing_type(std::istream &in);
	virtual void write_knowing_type(std::ostream &out) const;

	// called to initialize the feature range command table used by
	// read_knowing_type
	void init_command_table(void);

	// command table for reading angle vector alphabets
	static NameToPtr *CommandTable;

    // local data
	string FeatName;		// the name of the ResidueFeature, owned by this
	const ResidueFeature* Feat;     // the ResidueFeature itself, 
					// only available in undertaker.
	int Offset;            // the residue index relative to the current residue
	
	vector<double> LowEnd;
	vector<double> HighEnd;
	// residue r is in class i if LowEnd[i]<=feat(r+Offset)<HighEnd[i]
	
	double Modulus;
	// for angles that wrap around, we need to do the comparions
	//	on a circle.
	// If modulus>0, then check range as if circle had circumference "modulus":
	//  (x-lo)-modulus*floor((x-lo)/modulus) < (hi-lo)-modulus*floor((hi-lo)/modulus) 
	
    protected:
	// read commands for each command
	static int ReadFeature(std::istream &in, Alphabet *change, AlphabetInputCommand *self);
	static int ReadModulus(std::istream &in, Alphabet *change, AlphabetInputCommand *self);
	static int ReadOffset(std::istream &in, Alphabet *change, AlphabetInputCommand *self);
	static int ReadRange(std::istream &in, Alphabet *change, AlphabetInputCommand *self);

	// print commands for each command
	void print_feature(std::ostream &out) const;
	void print_modulus(std::ostream &out) const;
	void print_offset(std::ostream &out) const;
	void print_ranges(std::ostream &out) const;

    	// Note: we constrain alphabets so that 
	//	LowEnd[i+1] = HighEnd[i]  (mod modulus) 
	// to  allow for sanity checks (like no missing classification).
	// QUESTION: do we want to modify definition to allow holes,
	//	with a default Base used for any uncovered ranges?
	bool ranges_ok(void) const;
	
    public:
	// required stuff for things derived from NamedClass
	static  IdObject *classID(void)
	{    return &FeatureRangeAlphabet::ID;
	}

	virtual IdObject *type(void) const
	{    return &FeatureRangeAlphabet::ID;
	}

	FeatureRangeAlphabet(void) 	
	{   Modulus = 0;
	}
	
        bool in_range(double x, unsigned int r) const
	{   assert(r<LowEnd.size());
	    if (Modulus==0) return (LowEnd[r]<=x && x < HighEnd[r]);
	    if (LowEnd.size()<=1) return true;
	    double diff1 = x - LowEnd[r];
	    double diff2 = HighEnd[r] - LowEnd[r];
	    double mod1 = diff1 -Modulus*floor(diff1/Modulus);
	    double mod2 = diff2 -Modulus*floor(diff2/Modulus);
	    return (mod1 < mod2);
	}
    
    // classify residue res_idx of conformation conf.
    //	If conf is NULL, use cra instead.
    friend Base FeatureRangeClassify(const Conformation* conf,
			    const ChainsResiduesAndAtoms *cra,
			    int res_idx,
			    const FeatureRangeAlphabet &al);
};

#endif // FEATURERANGEALPHABET

// CHANGE LOG:
// Fri Aug 14 16:47:32 PDT 2009 Kevin Karplus
//	Added in_range() and remove set_feature()
// Fri Aug 14 17:01:22 PDT 2009 Kevin Karplus
//	Made in_range() const