def __init__(self, mode, lattice_vectors, name=None, sigma=1.0, offs=0.0):
        util.print_status_line()

        if name is not None:
            name = "_" + name
            suffix = name
        else:
            suffix = ""

        _collective_variable.__init__(self, sigma, name)

        if len(lattice_vectors) == 0:
            globals.msg.error(
                "cv.lamellar: List of supplied latice vectors is empty.\n")
            raise RuntimeEror('Error creating collective variable.')

        if type(mode) != type(dict()):
            globals.msg.error(
                "cv.lamellar: Mode amplitudes specified incorrectly.\n")
            raise RuntimeEror('Error creating collective variable.')

        cpp_mode = hoomd.std_vector_scalar()
        for i in range(
                0,
                globals.system_definition.getParticleData().getNTypes()):
            t = globals.system_definition.getParticleData().getNameByType(i)

            if t not in mode.keys():
                globals.msg.error(
                    "cv.lamellar: Missing mode amplitude for particle type " +
                    t + ".\n")
                raise RuntimeEror('Error creating collective variable.')
            cpp_mode.append(mode[t])

        cpp_lattice_vectors = _metadynamics.std_vector_int3()
        for l in lattice_vectors:
            if len(l) != 3:
                globals.msg.error(
                    "cv.lamellar: List of input lattice vectors not a list of triples.\n"
                )
                raise RuntimeError('Error creating collective variable.')
            cpp_lattice_vectors.append(hoomd.make_int3(l[0], l[1], l[2]))

        if not globals.exec_conf.isCUDAEnabled():
            self.cpp_force = _metadynamics.LamellarOrderParameter(
                globals.system_definition, cpp_mode, cpp_lattice_vectors, offs,
                suffix)
        else:
            self.cpp_force = _metadynamics.LamellarOrderParameterGPU(
                globals.system_definition, cpp_mode, cpp_lattice_vectors, offs,
                suffix)

        globals.system.addCompute(self.cpp_force, self.force_name)
    def __init__(self, qstar, mode, nx, ny=None, nz=None, name=None,sigma=1.0,zero_modes=None):
        util.print_status_line()

        if name is not None:
            name = "_" + name
            suffix = name
        else:
            suffix = "" 

        if ny is None:
            ny = nx

        if nz is None:
            nz = nx

        _collective_variable.__init__(self, sigma, name)

        if type(mode) != type(dict()):
                globals.msg.error("cv.mesh: Mode amplitudes specified incorrectly.\n")
                raise RuntimeEror('Error creating collective variable.')

        cpp_mode = hoomd.std_vector_scalar()
        for i in range(0, globals.system_definition.getParticleData().getNTypes()):
            t = globals.system_definition.getParticleData().getNameByType(i)

            if t not in mode.keys():
                globals.msg.error("cv.mesh: Missing mode amplitude for particle type " + t + ".\n")
                raise RuntimeEror('Error creating collective variable.')
            cpp_mode.append(mode[t])

        cpp_zero_modes = _metadynamics.std_vector_int3()
        if zero_modes is not None:
            for l in zero_modes:
                if len(l) != 3:
                    globals.msg.error("cv.lamellar: List of modes to zero not a list of triples.\n")
                    raise RuntimeError('Error creating collective variable.')
                cpp_zero_modes.append(hoomd.make_int3(l[0], l[1], l[2]))

        if not globals.exec_conf.isCUDAEnabled():
            self.cpp_force = _metadynamics.OrderParameterMesh(globals.system_definition, nx,ny,nz,qstar, cpp_mode, cpp_zero_modes)
        else:
            self.cpp_force = _metadynamics.OrderParameterMeshGPU(globals.system_definition, nx,ny,nz,qstar, cpp_mode, cpp_zero_modes)

        globals.system.addCompute(self.cpp_force, self.force_name)
    def __init__(self, mode, lattice_vectors, name=None,sigma=1.0,offs=0.0):
        util.print_status_line()

        if name is not None:
            name = "_" + name
            suffix = name
        else:
            suffix = "" 

        _collective_variable.__init__(self, sigma, name)

        if len(lattice_vectors) == 0:
                globals.msg.error("cv.lamellar: List of supplied latice vectors is empty.\n")
                raise RuntimeEror('Error creating collective variable.')
     
        if type(mode) != type(dict()):
                globals.msg.error("cv.lamellar: Mode amplitudes specified incorrectly.\n")
                raise RuntimeEror('Error creating collective variable.')

        cpp_mode = hoomd.std_vector_scalar()
        for i in range(0, globals.system_definition.getParticleData().getNTypes()):
            t = globals.system_definition.getParticleData().getNameByType(i)

            if t not in mode.keys():
                globals.msg.error("cv.lamellar: Missing mode amplitude for particle type " + t + ".\n")
                raise RuntimeEror('Error creating collective variable.')
            cpp_mode.append(mode[t])

        cpp_lattice_vectors = _metadynamics.std_vector_int3()
        for l in lattice_vectors:
            if len(l) != 3:
                globals.msg.error("cv.lamellar: List of input lattice vectors not a list of triples.\n")
                raise RuntimeError('Error creating collective variable.')
            cpp_lattice_vectors.append(hoomd.make_int3(l[0], l[1], l[2]))

        if not globals.exec_conf.isCUDAEnabled():
            self.cpp_force = _metadynamics.LamellarOrderParameter(globals.system_definition, cpp_mode, cpp_lattice_vectors, offs,suffix)
        else:
            self.cpp_force = _metadynamics.LamellarOrderParameterGPU(globals.system_definition, cpp_mode, cpp_lattice_vectors, offs, suffix)

        globals.system.addCompute(self.cpp_force, self.force_name)
    def __init__(self,
                 qstar,
                 mode,
                 nx,
                 ny=None,
                 nz=None,
                 name=None,
                 sigma=1.0,
                 zero_modes=None):
        util.print_status_line()

        if name is not None:
            name = "_" + name
            suffix = name
        else:
            suffix = ""

        if ny is None:
            ny = nx

        if nz is None:
            nz = nx

        _collective_variable.__init__(self, sigma, name)

        if type(mode) != type(dict()):
            globals.msg.error(
                "cv.mesh: Mode amplitudes specified incorrectly.\n")
            raise RuntimeEror('Error creating collective variable.')

        cpp_mode = hoomd.std_vector_scalar()
        for i in range(
                0,
                globals.system_definition.getParticleData().getNTypes()):
            t = globals.system_definition.getParticleData().getNameByType(i)

            if t not in mode.keys():
                globals.msg.error(
                    "cv.mesh: Missing mode amplitude for particle type " + t +
                    ".\n")
                raise RuntimeEror('Error creating collective variable.')
            cpp_mode.append(mode[t])

        cpp_zero_modes = _metadynamics.std_vector_int3()
        if zero_modes is not None:
            for l in zero_modes:
                if len(l) != 3:
                    globals.msg.error(
                        "cv.lamellar: List of modes to zero not a list of triples.\n"
                    )
                    raise RuntimeError('Error creating collective variable.')
                cpp_zero_modes.append(hoomd.make_int3(l[0], l[1], l[2]))

        if not globals.exec_conf.isCUDAEnabled():
            self.cpp_force = _metadynamics.OrderParameterMesh(
                globals.system_definition, nx, ny, nz, qstar, cpp_mode,
                cpp_zero_modes)
        else:
            self.cpp_force = _metadynamics.OrderParameterMeshGPU(
                globals.system_definition, nx, ny, nz, qstar, cpp_mode,
                cpp_zero_modes)

        globals.system.addCompute(self.cpp_force, self.force_name)