GRSpringForceIndex.h

#ifndef GRSpaceForceFunction2_H
#define GRSpaceForceFunction2_H
 
/*
  GUIDO Library
  Copyright (C) 2002  Holger Hoos, Juergen Kilian, Kai Renz
  Copyright (C) 2002-2017 Grame
 
  This Source Code Form is subject to the terms of the Mozilla Public
  License, v. 2.0. If a copy of the MPL was not distributed with this
  file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
  Grame Research Laboratory, 11, cours de Verdun Gensoul 69002 Lyon - France
  research@grame.fr
 
*/
 
#include "kf_ilist.h"
#include "kf_vect.h"
#include "GRSpring.h"
 
const float optimumforce = 800;
 
class GRSpaceForceFunction2;
 
class GRSpringForceIndex
{
        friend class GRSpaceForceFunction2;
 
    public:
        GRSpringForceIndex(GRSpring * p_spr,float p_force,int p_index)
        {
            spr = p_spr;
            force = p_force;
            index = p_index;
        }
        ~GRSpringForceIndex() {}
 
    protected:
 
        GRSpring * spr;
        float     force;
        int       index;
};
 
 
 
// typedef KF_IPointerList<GRSpring> SpringList;
typedef KF_IPointerList<GRSpringForceIndex> SortedForceList;
//typedef KF_Vector<float> FloatArray;
 
class GRSpaceForceFunction2
{
    public:
 
                         GRSpaceForceFunction2(float force);
        virtual         ~GRSpaceForceFunction2();
                        // Copy ctor, do I copy the springs? not really? do i?
                         GRSpaceForceFunction2(const GRSpaceForceFunction2 &sff);
 
        void    setOptForce(float newoptforce);
 
        void writeAllExtents(std::ostream& os) const;
 
        float EvaluateBreak(float extent);
        void UnfreezeSpring(GRSpring *spr);
        void FreezeSpring(GRSpring *spr);
        void ResetSprings();
        void addSFF(const GRSpaceForceFunction2 &sff);
 
        float getOptForce();
 
 
        void addSpring(GRSpring *spr);
        void deleteSpring(GRSpring *spr);
        float getExtent(float force) const;
        float getForce(float extent);
 
        float getOptConstant() const    { return copt; }
        float getXminOpt() const    { return xminopt; }
 
    protected:
        static float CalcSpringConstant( float c1, float c2 )   { return (c1 * c2) / (c1 + c2); }
 
        SortedForceList sortedlist;
 
        float xmin; // the sum of all lengths of all prestretched springs
        float cmax; // the maximum spring-constant
                    // if all springs need to be stretched.
        float xminopt; // This is the xmin-value for the optimum force
        float copt;  // this is the spring-constant for the optimum force 
 
        float optforce;
};
 
 
#endif