CompoundSystem.h

Go to the documentation of this file.

#ifndef SimTK_MOLMODEL_COMPOUNDSYSTEM_H_
#define SimTK_MOLMODEL_COMPOUNDSYSTEM_H_

#include "SimTKsimbody.h"
#include "molmodel/internal/common.h"
#include "molmodel/internal/Compound.h"
#include "molmodel/internal/MolecularMechanicsSystem.h"
#include "molmodel/internal/DuMMForceFieldSubsystem.h"

#include <map>

namespace SimTK {

class SimTK_MOLMODEL_EXPORT CompoundSystem : public MolecularMechanicsSystem {
public:
    CompoundSystem() 
//        : matter(*this), decorations(*this)
    {}

    ~CompoundSystem() {
        for (int i=0; i < (int)compounds.size(); ++i)
            delete compounds[i];
    }

    // const SimbodyMatterSubsystem& getMatter() const {return matter;}
    // SimbodyMatterSubsystem& updMatter() {return matter;}

    // const DecorationSubsystem& getDecorations() const {return decorations;}
    // DecorationSubsystem& updDecorations() {return decorations;}

    Compound::Index adoptCompound(
        Compound& child, 
        const Transform& compoundTransform = Transform() 
        ) 
    {
        const Compound::Index id((int)compounds.size());

        compounds.push_back(new Compound((CompoundRep*)0)); // grow
        Compound& c = *compounds.back(); // refer to the empty handle we just created

        child.disown(c); // transfer ownership to c

        // Now tell the Compound object its owning CompoundSystem and id within
        // that System.
        c.setCompoundSystem(*this, id);

        // Save transform
        // March 6, 2008 -- adjust internal Transform of Compound, rather than 
        // saving the Transform in CompoundSystem
        c.setTopLevelTransform(compoundTransform * c.getTopLevelTransform());
        // assert((int) compoundTransforms.size() == (int) id);
        // compoundTransforms.push_back(compoundTransform);

        return id;
    }

    void modelCompounds();

    size_t             getNumCompounds() const {return compounds.size();}

    const Compound& getCompound(Compound::Index i 
        ) const {return *compounds.at(i);}

    Compound&       updCompound(Compound::Index i 
        )       {return *compounds.at(i);}

private:

    void modelOneCompound(Compound::Index compoundId);

    void setClusterCompound(DuMM::ClusterIndex clusterIx, const Compound& compound) 
    {
        assert(! clusterHasCompound(clusterIx));
        compoundPtrsByClusterIndex[clusterIx] = &compound;
        assert(clusterHasCompound(clusterIx));
    }

    bool clusterHasCompound(DuMM::ClusterIndex clusterIx) {
        return compoundPtrsByClusterIndex.find(clusterIx) != compoundPtrsByClusterIndex.end();
    }

    void generateTopologyFromCompounds();

    // suppress
    CompoundSystem(const CompoundSystem&);
    CompoundSystem& operator=(const CompoundSystem&);

    // std::vector<Transform> compoundTransforms;

    // retarded visual studio compiler complains about being unable to 
    // export private stl class members
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4251)
#endif

    std::vector<Compound*> compounds;
    std::map<DuMM::ClusterIndex, const Compound*> compoundPtrsByClusterIndex;
    std::map<DuMM::ClusterIndex, int> clusterAtomCounts;
    std::map<DuMM::ClusterIndex, MobilizedBodyIndex> clusterBodies;

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

    // SimbodyMatterSubsystem matter;
    // DecorationSubsystem decorations;
};

} // namespace SimTK

#endif // SimTK_MOLMODEL_COMPOUNDSYSTEM_H_