Exemple #1
0
 def receiveTarget(self):
     self.clientSock.send("receivingTarget")
     data = self.clientSock.recv(1024)
     self.clientSock.send("targetReceived")
     radecS = data.split(":")
     Ra = Angle(r=float(radecS[0]))
     Dec = Angle(r=float(radecS[1]))
     return [Ra, Dec]
Exemple #2
0
def test_angle_class_hms_and_dms_must_be_consistent():
    a = Angle(d=1)

    a.dms = (1, 1, 0, 0)
    assert a.hms.hms == (1, 0, 4, 0.0)

    a.hms = (1, 1, 0, 0)
    assert a.dms.dms == (1, 15, 0, 0.0)
Exemple #3
0
def test_angle_class_hms_and_dms_must_be_consistent():
    a = Angle(d=1)

    a.dms = (1, 1, 0, 0)
    assert a.hms.hms == (1, 0, 4, 0.0)

    a.hms = (1, 1, 0, 0)
    assert a.dms.dms == (1, 15, 0, 0.0)
 def correct(self,Az,Alt):
     tVec = self.AzAltToVec(Az.r, Alt.r)
     tV = np.matrix([tVec])
     dVec = self.rotationMatrix*tV.T
     [rAz, rAlt] = self.VecToAzAlt(dVec)
     aAz = Angle(r=rAz)
     aAlt = Angle(r=rAlt)
     return [aAz,aAlt]       
Exemple #5
0
    def __init__(self, parent=None):
        super().__init__(parent)
        self.offset = 75
        self.span = self.offset + 525
        self.center = QPoint(self.span / 2, self.span / 2)
        self.setMinimumSize(self.span, self.span)
        self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
        self.setMouseTracking(True)

        self.wedges = []
        for start in range(0, 360 * 16, 45 * 16):
            self.wedges.append(
                CompassWedge(
                    start, self.span, self.span, self.offset,
                    Angle(floor(((360 - start / 16 + 45) % 360) / 45)), self))

        deg_font = QFont("Consolas", 22, 2)
        for deg in range(8):
            temp = QLabel(self)
            angle = deg * 45
            temp.setText(str(angle) + '°')
            temp.setFont(deg_font)
            tw = temp.fontMetrics().boundingRect(temp.text()).width()
            th = temp.fontMetrics().boundingRect(temp.text()).height()
            temp.move(self.deg_lbl_pos((180 - angle) % 360, QSize(tw, th)))
 def __init__(self, upCalibration, downCalibration):
     self.upCalibration = upCalibration
     self.downCalibration = downCalibration
     self.lastPosition = Angle(d=0)
     self.ascending = True
     self.voltageRecord = [0, 0]
     self.buffer = 0.0002
    def voltageToAngle(self, volts):
        power = 0
        degrees = 0
        for c in reversed(self.coeficients):
            degrees += math.pow(volts, power) * c
            power += 1

        return (Angle(d=degrees))
Exemple #8
0
def test_angle_class_getting_hms_property_must_work():
    a = Angle(d=45.0)

    assert a.hms.sign == 1
    assert a.hms.hh == 3.0
    assert a.hms.mm == 0.0
    assert a.hms.ss == 0.0
    assert a.hms.hms == (1, 3, 0.0, 0.0)
    assert str(a.hms) == ("+03HH 00MM 00.000SS")

    a = Angle(sg="-12h14m13.567s")

    assert a.hms.sign == -1
    assert a.hms.hh == 12
    assert a.hms.mm == 14
    assert a.hms.ss == 13.567
    assert a.hms.hms == (-1, 12, 14, 13.567)
    assert str(a.hms) == "-12HH 14MM 13.567SS"
Exemple #9
0
def test_angle_class_getting_dms_property_must_work():
    a = Angle(d=45.0)

    assert a.dms.sign == 1
    assert a.dms.dd == 45.0
    assert a.dms.mm == 0.0
    assert a.dms.ss == 0.0
    assert a.dms.dms == (1, 45, 0.0, 0.0)
    assert str(a.dms) == ("+45DD 00MM 00.000SS")

    a = Angle(sg="-12h14m13.567s")

    assert a.dms.sign == -1
    assert a.dms.dd == 183
    assert a.dms.mm == 33
    assert a.dms.ss == 23.505
    assert a.dms.dms == (-1, 183, 33, 23.505)
    assert str(a.dms) == "-183DD 33MM 23.505SS"
Exemple #10
0
def test_angle_class_setting_hms_property_must_work():
    a = Angle(d=0.0)

    a.hms = (1, 12, 14, 13.567)
    v = 12 + 14 / 60.0 + 13.567 / 3600.0
    assert a.h == v
    assert a.hms.sign == 1
    assert a.hms.hh == 12
    assert a.hms.mm == 14
    assert a.hms.ss == 13.567
    assert str(a.hms) == "+12HH 14MM 13.567SS"

    a.hms.hh = 15
    assert a.h == 15 + 14 / 60.0 + 13.567 / 3600.0

    a.hms.mm = 15
    assert a.h == 15 + 15 / 60.0 + 13.567 / 3600.0

    a = Angle(d=0.0)
    a.hms.mm = 12
    assert round(a.h, 15) == 12 / 60.0
Exemple #11
0
def test_angle_class_setting_dms_property_must_work():
    a = Angle(d=0.0)

    a.dms = (-1, 183, 33, 23.505)
    v = -1 * (183 + 33 / 60.0 + 23.505 / 3600.0)
    assert a.d == v
    assert a.dms.sign == -1
    assert a.dms.dd == 183
    assert a.dms.mm == 33
    assert a.dms.ss == 23.505
    assert str(a.dms) == "-183DD 33MM 23.505SS"

    a.dms.dd = 101
    assert a.d == -101.55652916666668

    a.dms.mm = 15
    assert a.d == -101.25652916666667

    a = Angle(d=0.0)
    a.dms.mm = 12
    assert round(a.d, 15) == 12 / 60.0
Exemple #12
0
def test_angle_class_setting_dms_property_must_work():
    a = Angle(d=0.0)

    a.dms = (-1, 183, 33, 23.505)
    v = -1 * (183 + 33/60.0 + 23.505/3600.0)
    assert a.d == v
    assert a.dms.sign == -1
    assert a.dms.dd == 183
    assert a.dms.mm == 33
    assert a.dms.ss == 23.505
    assert str(a.dms) == "-183DD 33MM 23.505SS"

    a.dms.dd = 101
    assert a.d == -101.55652916666668

    a.dms.mm = 15
    assert a.d == -101.25652916666667

    a = Angle(d=0.0)
    a.dms.mm = 12
    assert round(a.d, 15) == 12/60.0
Exemple #13
0
def test_angle_class_setting_hms_property_must_work():
    a = Angle(d=0.0)

    a.hms = (1, 12, 14, 13.567)
    v = 12 + 14/60.0 + 13.567/3600.0
    assert a.h == v
    assert a.hms.sign == 1
    assert a.hms.hh == 12
    assert a.hms.mm == 14
    assert a.hms.ss == 13.567
    assert str(a.hms) == "+12HH 14MM 13.567SS"

    a.hms.hh = 15
    assert a.h == 15 + 14/60.0 + 13.567/3600.0

    a.hms.mm = 15
    assert a.h == 15 + 15/60.0 + 13.567/3600.0

    a = Angle(d=0.0)
    a.hms.mm = 12
    assert round(a.h, 15) == 12/60.0
Exemple #14
0
def test_angle_class_must_initialize_properly():
    a = Angle(sg="12h14m13.567s")
    val = 12 + 14 / 60.0 + 13.567 / 3600.0
    assert a.h == val
    assert a.ounit == 'hours'
    assert a.r == h2r(val)
    assert a.d == h2d(val)
    assert a.arcs == h2arcs(val)

    # ignore r
    with pytest.warns(UserWarning):
        Angle(sg="12h14m13.567s", r=10)

    a = Angle(sg="12h14m13.567s", r=10)
    assert a.r == h2r(val)
    assert a.ounit == 'hours'

    # ignore h and mm
    with pytest.warns(UserWarning):
        a = Angle(r=10, h=20)

    a = Angle(r=10, h=20)
    assert a.r == 10
    assert a.ounit == 'radians'
    assert a.h == r2h(10)

    a = Angle(h=20, d=10)
    assert a.d == 10
    assert a.ounit == 'degrees'
    assert a.h == d2h(10)
Exemple #15
0
def loadProjParams(projName):
    """
    This function loads projections.txt file, which includes different
    projections with their correspoding parameters. A sample raw of this
    file has the following format:
    TM3-EAST, TM, BESSEL, 0.9999, 34, 26:42:58.815, 200000, 0
    where each comma delimited value corresponds to:
    projID, projFamily, ellipsoid, scale, lat0, lon0, falseEasting,
    falseNorthing respectively.
    It should be stated here that lat0, lon0 are defined in degrees
    (dms format, e.g. -0:23:9.01239573) within file.
    Arguments
        projName: string that specifies projection's ID,
                  could be one of the followings:
                    'TM3-WEST', 'TM3-CENTRAL', 'TM3-EAST', 'TM87',
                     'UTM-34N', 'UTM-35N', 'HATT', 'TM87-WGS84'

                  * If user desires to add another projection has to modify
                    projections.txt file following its header's instructions
    Returns
        dictionary of projection's parameters, i.e.
        {'projID': string, 'projFamily': string, 'ellipsoid': string,
        'scale': number, 'lat0': number, 'lon0': number,
        'falseEasting': number, 'falseNorthing': number}

        * values of dictionary could be None if they are missing from file
        * CAUTION. lat0, lon0 inserted as degrees in dms format but returned
          in radians
    """  
    with open("projections.txt") as fObj:
        readCSV = reader(fObj, delimiter=',')
        header = [value.strip() for value in next(readCSV)]
        projParams = dict.fromkeys(header)
        for line in readCSV:
            if line[0].strip() == projName:
                for key, value in zip(header, line):
                    projParams[key] = value.strip()
                for key in ['scale', 'falseEasting', 'falseNorthing']:
                    if projParams[key]:
                        projParams[key] = float(projParams[key])
                for key in ['lat0', 'lon0']:
                    if projParams[key]:
                        # projParams[key] = DMStoRads(projParams[key])
                        projParams[key] = Angle(projParams[key])
                return projParams
        raise Exception("The projection you defined does not exist "
                        "in projections.txt file")
Exemple #16
0
    def setAngleMenu(self, angleName):
        while (True):
            print "** Enter %s\n" % angleName
            print "** Use one of the following formats:"
            print "** Option 1: Degrees \"D\" e.g. 15.1275"
            print "** Option 2: Degrees:Minutes \"DD:M\" e.g. 15:7.65"
            print "** Option 3: Degrees:Minutes:Seconds \"DD:MM:SS\" e.g. 15:07:39"
            print "** %s:" % angleName

            uInput = raw_input()

            try:
                theAngle = Angle(uInput)
                return theAngle
                break
            except ValueError as e:
                print "There was an error in the angle value that you entered: %s" % e.message
Exemple #17
0
def invTM(E, N, projection):
    """
    geodetic values in radians
    ellipsoid of class Ellipsoid
    m0 scale factor
    E0, N0 false Easting, Northing in meters
    returns projected coordinates of a point in meters
    """
    ellipsoid = projection.ellipsoid
    m0 = projection.m0
    lat0 = projection.lat0.radians
    lon0 = projection.lon0.radians
    E0 = projection.E0
    N0 = projection.N0
    
    S = N / m0
    lat = latFromMeridianLength(lat0, S, ellipsoid)

    t = tan(lat)
    hta2 = ellipsoid.ePrimeSquared * (cos(lat)**2)
    E = E - E0
    W = sqrt(1 - ellipsoid.eSquared * (sin(lat))**2)
    N = ellipsoid.a / W
    Q = E / (m0 * N)
    M = ellipsoid.a * (1 - ellipsoid.eSquared) / (W**3)

    T10 = t / (2 * m0**2 * M * N)
    T11 = (t / (24 * m0**4 * M * N**3)) *\
          (5 + (3 * t**2) + hta2 - (4 * hta2**2) - (9 * t**2 * hta2))
    T12 = (t / (720 * m0**6 * M * N**5)) *\
          (61 + (90 * t**2) + (45 * t**4) + (46 * hta2) - (252 * t**2 * hta2) -
           (3 * hta2**2) + (100 * hta2**3) - (66 * t**2 * hta2**2) -
           (90 * t**4 * hta2) + (88 * hta2**4) + (225 * t**4 * hta2**2) +
           (84 * t**2 * hta2**3) - (192 * t**2 * hta2**4))
    T13 = (t / (40320 * m0**8 * M * N**7)) *\
          (1385 + (3633 * t**2) + (4095 * t**4) + (1575 * t**6))
    T14 = 1 / cos(lat)
    T15 = (1 + (2 * t**2) + hta2) / (6 * cos(lat))
    T16 = (5 + (6 * hta2) + (28 * t**2) - (3 * hta2**2) + (8 * t**2 * hta2) +
           (24 * t**4) - (4 * hta2**3) + (4 * t**2 * hta2**2) +
           (24 * t**2 * hta2**3)) / (120 * cos(lat))
    T17 = (61 + (66 * t**2) + (1320 * t**4) + (720 * t**6)) / 5040

    lat = lat - (T10 * E**2) + (T11 * E**4) - (T12 * E**6) + (T13 * E**8)
    lon = lon0 + (T14*Q) - (T15 * Q**3) + (T16 * Q**5) - (T17 * Q**7)

    lat = Angle(lat)
    lat.angleType = 'dms'
    lon = Angle(lon)
    lon.angleType = 'dms'
    return lat, lon
Exemple #18
0
 def log_item(self, data):
     last_unlogged = self.timeout_timer.isActive()
     self.timeout_timer.start()
     src = self.sender()
     if type(src) is ActionsWidget:
         if self.exact_angle.has_valid():
             if self.exact_angle.is_valid():
                 self.log_angle(self.exact_angle.calc_angle())
             self.exact_angle.clear_state()
         if src.source is LogSource.SYSTEM:
             self.log_system(src.get_action(data))
             if last_unlogged:
                 self.update_temp_log()
         elif src.source is LogSource.EVENT:
             self.log_event(src.get_action(data))
     elif type(src) is Compass:
         self.log_compass(Angle.to_string(data))
     elif type(src) is ExactAngle:
         self.log_angle(str(data))
Exemple #19
0
def test_angle_class_must_handle_assignments():
    a = Angle(d=10.5)
    a.r = d2r(45.0)

    v = 45.0
    assert a.r == d2r(v)
    assert a.h == d2h(v)
    assert a.arcs == d2arcs(v)
    assert a.ounit == 'degrees'

    v = 46.0
    # assignment
    a.r = d2r(v)
    assert a.r == d2r(v)
    assert a.h == d2h(v)
    assert a.d == v
    assert a.arcs == d2arcs(v)
    assert a.ounit == 'degrees'  # no change

    v = 49.0
    a.d = v
    assert a.r == d2r(v)
    assert a.h == d2h(v)
    assert a.d == v
    assert a.arcs == d2arcs(v)
    assert a.ounit == 'degrees'  # no change

    v = 10
    a.h = v
    assert a.r == h2r(v)
    assert a.h == v
    assert a.d == h2d(v)
    assert a.arcs == h2arcs(v)
    assert a.ounit == 'degrees'  # no change

    v = 3600.0
    a.arcs = v
    assert a.r == arcs2r(v)
    assert a.h == arcs2h(v)
    assert a.d == arcs2d(v)
    assert a.arcs == v
    assert a.ounit == 'degrees'  # no change
Exemple #20
0
def test_angle_class_must_handle_assignments():
    a = Angle(d=10.5)
    a.r = d2r(45.0)

    v = 45.0
    assert a.r == d2r(v)
    assert a.h == d2h(v)
    assert a.arcs == d2arcs(v)
    assert a.ounit == 'degrees'

    v = 46.0
    # assignment
    a.r = d2r(v)
    assert a.r == d2r(v)
    assert a.h == d2h(v)
    assert a.d == v
    assert a.arcs == d2arcs(v)
    assert a.ounit == 'degrees'  # no change

    v = 49.0
    a.d = v
    assert a.r == d2r(v)
    assert a.h == d2h(v)
    assert a.d == v
    assert a.arcs == d2arcs(v)
    assert a.ounit == 'degrees'  # no change

    v = 10
    a.h = v
    assert a.r == h2r(v)
    assert a.h == v
    assert a.d == h2d(v)
    assert a.arcs == h2arcs(v)
    assert a.ounit == 'degrees'  # no change

    v = 3600.0
    a.arcs = v
    assert a.r == arcs2r(v)
    assert a.h == arcs2h(v)
    assert a.d == arcs2d(v)
    assert a.arcs == v
    assert a.ounit == 'degrees'  # no change
Exemple #21
0
def ECEFtoGeodetic(X, Y, Z, ellipsoid):
    """
    X, Y, Z in meters
    ellipsoid: class ellipsoid
    returns Geodetic lat, lon in Angle and h in meters
    """
    lon = atan2(Y, X)
    P = sqrt(X**2 + Y**2)
    lat0 = atan2((Z * (1 + ellipsoid.ePrimeSquared)), P)
    dlat = 1
    while dlat > 10**-12:
        W = sqrt(1 - ellipsoid.eSquared * (sin(lat0))**2)
        N = ellipsoid.a / W
        lat = atan2((Z + ellipsoid.eSquared * N * sin(lat0)), P)
        dlat = abs(lat - lat0)
        lat0 = lat
    h = (Z / sin(lat)) - ((1 - ellipsoid.eSquared) * N)

    lat = Angle(lat)
    lat.angleType = 'dms'
    lon = Angle(lon)
    lon.angleType = 'dms'
    return lat, lon, h
 def getLatLon(self):
     uLat = self.getGeneric('location', 'latitude')
     Lat = Angle(r=float(uLat))
     uLon = self.getGeneric('location', 'longitude')
     Lon = Angle(r=float(uLon))
     return [Lat,Lon]
def main():
    """
    This test shows various operators within Angle and AngleContainer classes.
    Shows memory management structure and access methods
    """

    p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
    p2 = Particle([2.2, 2.2, 2.2], "Si", 1.0, 2.34)
    p3 = Particle([3.3, 3.3, 3.3], "Si", 1.0, 2.34)
    #
    p4 = Particle([4.4, 4.4, 4.4], "C", 1.0, 2.34)  # ptcl 1
    p5 = Particle([5.5, 5.5, 5.5], "C", 1.0, 2.34)  # ptcl 2
    p6 = Particle([6.6, 6.6, 6.6], "C", 1.0, 2.34)  # ptcl 3

    b1 = Bond(1, 2, 1.11, "hooke")
    b2 = Bond(2, 3, 2.22, "hooke")
    #
    b3 = Bond(1, 2, 3.33, "hooke")
    b4 = Bond(2, 3, 4.44, "hooke")

    a1 = Angle(1, 2, 3, 1.11, "harmonic")
    #
    a2 = Angle(1, 2, 3, 2.22, "harmonic")

    atoms1 = ParticleContainer()
    atoms2 = ParticleContainer()
    atoms1.put(p1)
    atoms1.put(p2)
    atoms1.put(p3)
    #
    atoms2.put(p4)
    atoms2.put(p5)
    atoms2.put(p6)

    bonds1 = BondContainer()
    bonds2 = BondContainer()
    bonds1.put(b1)
    bonds1.put(b2)
    bonds2.put(b3)
    bonds2.put(b4)

    angles1 = AngleContainer()
    angles2 = AngleContainer()
    angles1.put(a1)
    angles2.put(a2)

    del p1, p2, p3, p4, p5, p6, b1, b2, b3, b4, a1, a2
    print "\n Cleaning memory for initial objects \n"

    print "angles1 container"
    print angles1

    print " "
    print "angles2 container"
    print angles2

    print "Testing 'in' operator (1 in angles1)"
    if (1 in angles1):
        print "angles1 contains gid 1"
    else:
        print "key not found in angles1"

    print "Testing 'in' operator (5 in angles1)"
    if (5 in angles1):
        print "angles1 contains gid 5"
    else:
        print "key not found in angles1"

    print " "
    angles1 += angles2
    print "Will print the new angles1 after adding angles1 += angles2"
    print angles1

    print "Check for pre-existing angle"
    if angles1.hasAngle([3, 2, 1]):
        print "angle 1--2--3 exists"
    else:
        print "angle 1--2--3 does NOT exists"

    print "Check for pre-existing angle"
    if angles1.hasAngle([2, 3, 1]):
        print "angle 2--3--1 exists"
    else:
        print "angle 2--3--1 does NOT exists"
def main():
    """
    Illustrates how a substructure method returns subgroup with ONLY particle container included
    This is for speed considerations
    """
    print "**********************************************************************************************"
    print "Illustrates how a substructure method returns subgroup with ONLY particle container included"
    print "This is for speed considerations"
    print "**********************************************************************************************\n"

    p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
    p2 = Particle([2.2, 2.2, 2.2], "Si", 1.0, 2.34)
    p3 = Particle([3.3, 3.3, 3.3], "Si", 1.0, 2.34)
    p4 = Particle([4.4, 4.4, 4.4], "Si", 1.0, 2.34)
    p5 = Particle([5.5, 5.5, 5.5], "C", 1.0, 2.34)  # 1
    p6 = Particle([6.6, 6.6, 6.6], "C", 1.0, 2.34)  # 2
    p7 = Particle([7.7, 7.7, 7.7], "C", 1.0, 2.34)  # 3
    p8 = Particle([8.8, 8.8, 8.8], "C", 1.0, 2.34)  # 4

    b1 = Bond(1, 2, 1.11, "hooke")
    b2 = Bond(2, 3, 2.22, "hooke")
    b3 = Bond(3, 4, 3.33, "hooke")
    b4 = Bond(4, 5, 4.44, "hooke")
    b5 = Bond(5, 6, 5.55, "hooke")
    b6 = Bond(6, 7, 6.66, "hooke")
    b7 = Bond(7, 8, 7.77, "hooke")

    a1 = Angle(1, 2, 3, 1.11, "harmonic")
    a2 = Angle(2, 3, 4, 2.22, "harmonic")
    a3 = Angle(3, 4, 5, 3.33, "harmonic")
    a4 = Angle(4, 5, 6, 4.44, "harmonic")
    a5 = Angle(5, 6, 7, 5.55, "harmonic")
    a6 = Angle(6, 7, 8, 6.66, "harmonic")

    d1 = Dihedral(1, 2, 3, 4, 1.11, "stiff")
    d2 = Dihedral(2, 3, 4, 5, 2.22, "stiff")
    d3 = Dihedral(3, 4, 5, 6, 3.33, "stiff")
    d4 = Dihedral(4, 5, 6, 7, 4.44, "stiff")
    d5 = Dihedral(5, 6, 7, 8, 5.55, "stiff")

    atoms1 = ParticleContainer()
    atoms1.put(p1)
    atoms1.put(p2)
    atoms1.put(p3)
    atoms1.put(p4)
    atoms1.put(p5)
    atoms1.put(p6)
    atoms1.put(p7)
    atoms1.put(p8)

    bonds = BondContainer()
    bonds.put(b1)
    bonds.put(b2)
    bonds.put(b3)
    bonds.put(b4)
    bonds.put(b5)
    bonds.put(b6)
    bonds.put(b7)

    angles = AngleContainer()
    angles.put(a1)
    angles.put(a2)
    angles.put(a3)
    angles.put(a4)
    angles.put(a5)
    angles.put(a6)

    dihedrals = DihedralContainer()
    dihedrals.put(d1)
    dihedrals.put(d2)
    dihedrals.put(d3)
    dihedrals.put(d4)
    dihedrals.put(d5)

    del p1, p2, p3, p4, p5, p6, p7, p8
    del b1, b2, b3, b4, b5, b6, b7
    del a1, a2, a3, a4, a5, a6
    del d1, d2, d3, d4, d5

    polymer1 = StructureContainer(atoms1, bonds, angles, dihedrals)
    del atoms1, bonds, angles, dihedrals

    print "********************************************************** \n"
    print "polymer1 Structure before returning sub-structure"
    print polymer1
    print "********************************************************** \n"

    print "-------------------------------------------------------------------------------- \n"

    print "********************************************************** \n"
    print "Testing polymer1.getSubParticleContainer([2,3,4])"
    print "   currently ID's are reassigned in substructure \n"
    subPtclC = polymer1.getSubStructure([2, 3, 4], particlesOnly=True)
    print subPtclC
    print "********************************************************** \n"
Exemple #25
0
def read_lmpdata( strucC , parmC , data_file):
    """
    Read Lammps data file


    Arguments:
        strucC     (StructureContainer)
        parmC      (ParameterContainer)
        data_file  (str) data file
    
    ReturnS:
        strucC     (StructureContainer)
        parmC      (ParameterContainer)
    
    """
        
    debug = 0
    verbose = True

    set_chain_numbers = True

    if( not set_chain_numbers ):
        print " Warning not reading in chain numbers!!! "

    # Load periodic table 
    pt = periodictable()
    

    F = open(data_file , 'r' )
    lines = F.readlines()
    F.close()
    
    #
    # Read in data header with number of parameters 
    #
    for line in lines:
        col = line.split()
        if ( len(col) >=2 ):
            # Read in number of each topolgical component  
            if( col[1] == "atoms" ):
                n_atoms = int( col[0] )
            elif( col[1] == "bonds" ):
                n_bonds = int( col[0] )
            elif( col[1] == "angles" ):
                n_angles = int( col[0] )
            elif( col[1] == "dihedrals" ):
                n_dihedrals = int( col[0] )
            elif( col[1] == "impropers" ):
                n_impropers = int( col[0] )

        if ( len(col) >= 3 ):
            # Read in number of each parameter type 
            if( col[1] == "atom" and   col[2] == "types" ):
                n_atypes = int( col[0] )
            elif( col[1] == "bond" and   col[2] == "types"  ):
                n_btypes = int( col[0] )
            elif( col[1] == "angle" and   col[2] == "types"  ):
                n_angtypes = int( col[0] )
            elif( col[1] == "dihedral" and   col[2] == "types"  ):
                n_dtypes = int( col[0] )
            elif( col[1] == "improper" and   col[2] == "types"  ):
                n_imptypes = int( col[0] )
                
        # Read in box size    
        if ( len(col) >= 4 ):
            if( col[2]  == "xlo"  and col[3]  == "xhi"  ):
                strucC.latvec[0][0] = float( col[1] ) - float( col[0] ) 
            if( col[2]  == "ylo"  and col[3]  == "yhi"  ):
                strucC.latvec[1][1] = float( col[1] ) - float( col[0] ) 
            if( col[2]  == "zlo"  and col[3]  == "zhi"  ):
                strucC.latvec[2][2] = float( col[1] ) - float( col[0] )

    # Prind debug
    if( verbose ):
        print " atoms ",n_atoms
        print " n_bonds ",n_bonds
        print " n_angles ",n_angles
        print " n_dihedrals ",n_dihedrals
        print " n_impropers ",n_impropers
        print ""
        print "n_atom_types",n_atypes
        print "n_bond_types",n_btypes
        print "n_angle_types",n_angtypes
        print "n_dihedral_types",n_dtypes
        print "n_imp_dihedral_types",n_imptypes



    # Check to see if a previous read has occured
    pt_overwrite = False
    if( len(strucC.ptclC) > 0 ):
        pt_overwrite = True
    # Check of conistent number of atoms
    if( pt_overwrite ):
        if(  len(strucC.ptclC)  != n_atoms):
            print "  %d atoms in passed structure "%(len(strucC.ptclC))
            print "  %d atoms in data file "%(n_atoms)
            sys.exit(" Inconsistent number of atoms " )

    else:
        #
        # Initialize particle container
        #
        for pid_i in range(n_atoms):
            pt_i = Particle( )
            strucC.ptclC.put(pt_i)

 
    bonds_overwrite = False
    if( len(strucC.bondC) > 0 ):
        bonds_overwrite = True

        if(  len(strucC.bondC)  != n_bonds):
            print "  %d bonds in passed structure "%(len(strucC.bondC))
            print "  %d bonds in data file "%(n_bonds)
            sys.exit(" Inconsistent number of bonds " )
    
    angles_overwrite = False
    if( len(strucC.angleC) > 0 ):
        angles_overwrite = True
        if(  len(strucC.angleC)  != n_angles):
            print "  %d angles in passed structure "%(len(strucC.angleC))
            print "  %d angles in data file "%(n_angles)
            sys.exit(" Inconsistent number of angles " )
    
    dih_overwrite = False
    if( len(strucC.dihC) > 0 ):
        dih_overwrite = True
        if(  len(strucC.dihC)  != n_dihedrals):
            print "  %d dihedrals in passed structure "%(len(strucC.dihC))
            print "  %d dihedrals in data file "%(n_dihedrals)
            sys.exit(" Inconsistent number of dihedrals " )
              
    imp_overwrite = False
    if( len(strucC.impC) > 0 ):
        imp_overwrite = True
        if(  len(strucC.impC)  != n_impropers):
            print "  %d impropers in passed structure "%(len(strucC.impC))
            print "  %d impropers in data file "%(n_impropers)
            sys.exit(" Inconsistent number of impropers " )          
            
    #
    # Intialize
    #   - read in boolean to off
    #
    read_Masses = 0
    read_Pair = 0
    read_Bond_coeff = 0
    read_Angle_coeff = 0
    read_Dihedral_coeff = 0
    read_Improper_coeff = 0
    
    read_Atoms = 0
    read_Bonds = 0
    read_Angles = 0
    read_Dihedrals = 0
    read_Impropers = 0
    
    #   - lists as indecise can be out of order in data file
    ATYPE_REF = n_atypes*[""]
    ATYPE_MASS = np.zeros(n_atypes)
    ATYPE_EP = np.zeros(n_atypes)
    ATYPE_SIG = np.zeros(n_atypes)
    
    BTYPE_REF = n_btypes*[2*[""]]
    BONDTYPE_R0 = np.zeros(n_btypes)
    BONDTYPE_K = np.zeros(n_btypes)
    
    ANGTYPE_REF = n_angtypes*[3*[""]]
    ANGLETYPE_R0 = np.zeros(n_angtypes)
    ANGLETYPE_K = np.zeros(n_angtypes)
    
    DTYPE_REF = n_dtypes*[4*[""]]
    DIHTYPE_C = np.zeros((n_dtypes,4))
    DIHTYPE_F = np.zeros(n_dtypes)
    DIHTYPE_K = np.zeros(n_dtypes)
    DIHTYPE_PN = np.zeros(n_dtypes)
    DIHTYPE_PHASE = np.zeros(n_dtypes)

    IMPTYPE_REF = n_imptypes*[4*[""]]
    IMPTYPE_F = np.zeros(n_imptypes)
    IMPTYPE_E0 = np.zeros(n_imptypes)
    IMPTYPE_K = np.zeros(n_imptypes)

    MOLNUMB = n_atoms*[0]
    ATYPE_IND  = n_atoms*[0]
    CHARGES  = np.zeros(n_atoms)
    R = n_atoms*[np.zeros(3)]
    ATYPE  = n_atoms*[""]
    
    BONDS = n_bonds*[[0,0]]
    BTYPE_IND = n_bonds*[0]
    
    ANGLES = n_angles*[[0,0,0]]
    ANGTYPE_IND = n_angles*[0]
    
    DIH = n_dihedrals*[[0,0,0,0]]
    DTYPE_IND = n_dihedrals*[0]


    

    #
    # Check if values exist and need to be updated or don't and need to be created 
    #
    ljtyp_update = False
    ljtyp_cnt = 0 
    if( len(parmC.ljtypC) > 0 ):
        print " LJ types will be updated "
        ljtyp_update = True
    btyp_update = False
    btyp_cnt = 0 
    if( len(parmC.btypC) > 0 ):
        print " Bond types will be updated "
        btyp_update = True
    atyp_update = False
    atyp_cnt = 0 
    if( len(parmC.atypC) > 0 ):
        print " Angle types will be updated "
        atyp_update = True
    dtyp_update = False
    dtyp_cnt = 0 
    if( len(parmC.dtypC) > 0 ):
        print " Dihedral types will be updated "
        dtyp_update = True
    imptyp_update = False
    imptyp_cnt = 0 
    if( len(parmC.imptypC) > 0 ):
        print " Improper dihedrals types will be updated "
        imptyp_update = True
    #
    # Read in data parameters 
    #
    
    for line in lines:
        col = line.split()
        if( read_Masses and  len(col) >= 2 ):
            
            cnt_Masses += 1
            ind = int(col[0]) - 1
            ATYPE_MASS[ind] = float(col[1])
                
            if( len(col) >= 4 ):
                ATYPE_REF[ind] = col[3]
                ptype1 = col[3]
            else:
                ATYPE_REF[ind] = "??"
                ptype1 = "??"
            
            mass_i = float(col[1])

        
            if( ljtyp_update ):
                ljtyp_cnt = ind  + 1
                if( ljtyp_cnt > len(parmC.ljtypC) ):
                    print "Mass index %d larger then length of previously read ljtypC %d"%(ind,len(parmC.ljtypC))
                ljtyp_i = parmC.ljtypC[ljtyp_cnt]
                ljtyp_i.setmass(mass_i)
            else:
                ljtyp_i = ljtype(ptype1)
                ljtyp_i.setmass(mass_i)
                parmC.ljtypC.put(ljtyp_i)
            
            # Turn of mass read
            if(cnt_Masses ==  n_atypes ):
                read_Masses = 0

        if( read_Pair and  len(col) >= 3 ):
            cnt_Pair += 1
            
            ind = int(col[0]) - 1
            ATYPE_EP[ind] = float(col[1])
            ATYPE_SIG[ind] = float(col[2])

            epsilon = float(col[1])
            sigma = float(col[2])
            ljtyp_ind = int(col[0])

            ljtyp_i = parmC.ljtypC[ljtyp_ind]
            ljtyp_i.setparam(epsilon,sigma)
            # Turn pair parameter read off 
            if(cnt_Pair >=  n_atypes ):
                read_Pair = 0

        
        if( read_Bond_coeff and  len(col) >= 3 ):
            cnt_Bond_coeff += 1
            #AT_i = int(col[0])
            #AT_j = int(col[1])
            b_ind = int( col[0]) - 1
            if( b_ind > n_btypes ):
                error_line = " Error in data file index of bond parameter exceeds number of bond parameters specified with bond types "
                sys.exit(error_line)
                
            BTYPE_REF[b_ind][0] = "??"
            BTYPE_REF[b_ind][1] = "??"
            BONDTYPE_K[b_ind] = float(col[1])
            BONDTYPE_R0[b_ind] = float(col[2])

            ptype1 = "??"
            ptype2 = "??"
            lmpindx = int( col[0])
            kb = float(col[1]) 
            r0 = float(col[2]) 
            btype = "harmonic"
            g_type = 1

            if( btyp_update ):
                btyp_cnt = b_ind + 1 
                btyp_i = parmC.btypC[btyp_cnt]
                btyp_i.setharmonic(r0,kb)
                btyp_i.set_g_indx(g_type)
                btyp_i.set_lmpindx(lmpindx)
            else:
                btyp_i = bondtype(ptype1,ptype2,btype)
                btyp_i.setharmonic(r0,kb)
                btyp_i.set_g_indx(g_type)
                btyp_i.set_lmpindx(lmpindx)
                parmC.btypC.put(btyp_i)
            
            if( cnt_Bond_coeff >=  n_btypes ):
                read_Bond_coeff = 0
                
        
        if( read_Angle_coeff and  len(col) >= 3 ):
            cnt_Angle_coeff += 1
            #AT_i = int(col[0])
            #AT_j = int(col[1])
            a_ind = int( col[0]) - 1
            if( a_ind > n_angtypes ):
                print sys.exit(" Error in data file index of angle parameter exceeds number of angle parameters specified with angle types ")
                
            ANGTYPE_REF[a_ind][0] = "??"
            ANGTYPE_REF[a_ind][1] = "??"
            ANGTYPE_REF[a_ind][2] = "??"
            ANGLETYPE_K[a_ind] = float(col[1])
            ANGLETYPE_R0[a_ind] = float(col[2])

            ptype1 = "??"
            ptype2 = "??"
            ptype3 = "??"
            lmpindx = int( col[0])
            theta0 = float( col[2] )        # degrees 
            kb =  float( col[1] ) 
            atype = "harmonic"
            gfunc_type = 1


            if( atyp_update ):
                atyp_cnt = a_ind + 1 
                atyp_i = parmC.atypC[atyp_cnt]
                atyp_i.set_g_indx(gfunc_type)
                atyp_i.set_lmpindx(lmpindx)
                atyp_i.setharmonic(theta0,kb)
            else:
                atyp_i = angletype(ptype1,ptype2,ptype3,atype)
                atyp_i.set_g_indx(gfunc_type)
                atyp_i.set_lmpindx(lmpindx)
                atyp_i.setharmonic(theta0,kb)
                parmC.atypC.put(atyp_i)
            
            if( cnt_Angle_coeff >=  n_angtypes ):
                read_Angle_coeff = 0
                
        
        if( read_Dihedral_coeff and  len(col) >= 3 ):
            cnt_Dihedral_coeff += 1
            #AT_i = int(col[0])
            #AT_j = int(col[1])
            d_ind = int( col[0]) - 1
            
            if( debug): print " reading dih type ",d_ind," cnt ",cnt_Dihedral_coeff," of ",n_dtypes
            
            if( d_ind > n_dtypes ):
                error_line =  " Error in data file index of dihedral parameter %d exceeds number of dihedral parameters %d "%(d_ind , n_dtypes)
                error_line += " specified with dihedral types "
                print sys.exit(error_line)
                
            DTYPE_REF[d_ind][0] = "??"
            DTYPE_REF[d_ind][1] = "??"
            DTYPE_REF[d_ind][2] = "??"
            DTYPE_REF[d_ind][3] = "??"
            
            # Assume OPLS dihedral type
            DIHTYPE_F[d_ind] = 3
            DIHTYPE_C[d_ind][0] = float(col[1])
            DIHTYPE_C[d_ind][1] = float(col[2])
            DIHTYPE_C[d_ind][2] = float(col[3])
            DIHTYPE_C[d_ind][3] = float(col[4])

            ptype1 = "??"
            ptype2 = "??"
            ptype3 = "??"
            ptype4 = "??"
            # Set parameters according to type 
            gfunc_type = 3 
            dtype = "opls"

            lmpindx = int( col[0] )
            k1 =  float( col[1] )
            k2 =  float( col[2] ) 
            k3 =  float( col[3] ) 
            k4 =  float( col[4] )


            if( dtyp_update ):
                dtyp_cnt = d_ind + 1 
                dtyp_i = parmC.dtypC[dtyp_cnt]
                dtyp_i.set_g_indx(gfunc_type)
                dtyp_i.set_lmpindx(lmpindx)
                dtyp_i.setopls(k1,k2,k3,k4)
            else:
                dtyp_i = dihtype(ptype1,ptype2,ptype3,ptype4,dtype)
                dtyp_i.set_g_indx(gfunc_type)
                dtyp_i.set_lmpindx(lmpindx)
                dtyp_i.setopls(k1,k2,k3,k4)
                parmC.dtypC.put(dtyp_i)
            
            if( cnt_Dihedral_coeff >=  n_dtypes ):
                read_Dihedral_coeff = 0
                
        
        if( read_Improper_coeff and  len(col) >= 3 ):
            cnt_Improper_coeff += 1
            #AT_i = int(col[0])
            #AT_j = int(col[1])
            imp_ind = int( col[0]) - 1
            
            if( debug): print " reading imp dih type ",imp_ind," cnt ",cnt_Improper_coeff," of ",n_imptypes
            
            if( imp_ind > n_imptypes ):
                error_line =  " Error in data file index of improper parameter %d exceeds number of improper parameters %d "%(imp_ind , n_imptypes)
                error_line += " specified with dihedral types "
                print sys.exit(error_line)
                
            IMPTYPE_REF[imp_ind][0] = "??"
            IMPTYPE_REF[imp_ind][1] = "??"
            IMPTYPE_REF[imp_ind][2] = "??"
            IMPTYPE_REF[imp_ind][3] = "??"
            
            # Assume OPLS dihedral type
            IMPTYPE_F[imp_ind] = 2
            KE = float(col[1])
            Eo = float(col[2])
            IMPTYPE_E0[imp_ind] = Eo
            IMPTYPE_K[imp_ind] = KE

            ptype1 = "??"
            ptype2 = "??"
            ptype3 = "??"
            ptype4 = "??"
            # Set parameters according to type 
            g_indx = 2
            dtype = "improper"

            lmpindx = int( col[0] )


            if( imptyp_update ):
                imptyp_cnt = imp_ind + 1 
                imptyp_i = parmC.imptypC[imptyp_cnt]
                imptyp_i.set_g_indx(g_indx)
                imptyp_i.setimp(Eo,KE)
                imptyp_i.set_lmpindx(lmpindx)                
            else:
                imptyp_i = imptype(ptype1,ptype2,ptype3,ptype4,dtype)
                imptyp_i.set_g_indx(g_indx)
                imptyp_i.setimp(Eo,KE)
                imptyp_i.set_lmpindx(lmpindx)
                parmC.imptypC.put(imptyp_i)
            
            if( cnt_Improper_coeff >=  n_imptypes ):
                read_Improper_coeff = 0
            
        if( read_Atoms and len(col) >= 7 ):
            cnt_Atoms += 1
            ind = int( col[0]) - 1
            if( ind > n_atoms ):
                print sys.exit(" Error in data file index of atoms exceeds number of atoms specified with atoms ")
            
            chain_i = int(col[1]) 
            lmptype_i = int(col[2]) #- 1
            indx = int(col[2]) - 1
            q_i = float(col[3])
            m_i = ATYPE_MASS[indx]
            fftype_i = ATYPE_REF[indx]
            el = pt.getelementWithMass(m_i)
            
            if( el.symbol == "VS" ):
                el.symbol = ATYPE_l[atom_indx].strip()
                fftype_i = "VS"
                m_i = 0.0 

            # HACK !!
            if( ATYPE_MASS[indx] == 9.0  ):
                el.symbol = "LP"
                fftype_i = "LP"
                m_i = 0.0
            
            r_i =  [ float(col[4]),float(col[5]),float(col[6])] 
            type_i = str(lmptype_i)

            #tagsD = {"chain":chain_i,"symbol":el.symbol,"number":el.number,"mass":el.mass,"cov_radii":el.cov_radii,"vdw_radii":el.vdw_radii}
            #if( pt_overwrite ):
            pt_i = strucC.ptclC[ind+1]
            pt_i.position = r_i

            update_coord = True
            if( not update_coord ):

                pt_i.type = el.symbol
                pt_i.charge = q_i
                pt_i.mass = m_i

                add_dict = pt_i.tagsDict
                # Set properties read in data file 
                if( set_chain_numbers ): add_dict["chain"] = chain_i
                add_dict["symbol"] = el.symbol
                add_dict["number"] = el.number
                add_dict["mass"] = el.mass
                add_dict["cov_radii"] = el.cov_radii
                add_dict["vdw_radii"] = el.vdw_radii
                add_dict["lmptype"] = lmptype_i
                add_dict["fftype"] = fftype_i 
                # 
                add_dict["ffmass"] = ATYPE_MASS[indx]
                add_dict["residue"] = chain_i
                add_dict["qgroup"] = chain_i
                add_dict["resname"] = "MOLR"
                add_dict["ring"] = 0
                add_dict["label"] = add_dict["symbol"]
                pt_i.setTagsDict(add_dict)

            
            if( cnt_Atoms >=  n_atoms ):
                read_Atoms = 0

        if(read_Bonds and len(col) >= 4 ):
            cnt_Bonds += 1
            ind = int( col[0]) - 1

            if( ind > n_bonds ):
                print sys.exit(" Error in data file index of bonds exceeds number of bonds specified with bonds ")
                
            BTYPE_IND[ind] = int(col[1] ) - 1
            BONDS[ind] = [int(col[2]) - 1 , int(col[3]) - 1 ]
            i_o = int(col[2])
            j_o = int(col[3])

            if( bonds_overwrite ):
                bondObj = strucC.bondC[cnt_Bonds]
                bondObj.pgid1 = i_o
                bondObj.pgid2 = j_o
                bondObj.set_lmpindx(int(col[1] ))
            else:
                bondObj = Bond( i_o, j_o )
                bondObj.set_lmpindx(int(col[1] ))
                strucC.bondC.put(bondObj)
                
            if( cnt_Bonds >=  n_bonds ):
                read_Bonds = 0

        if(read_Angles and len(col) >= 5 ):
            cnt_Angles += 1
            ind = int( col[0]) - 1
            ANGTYPE_IND[ind] = int(col[1] ) - 1
            ANGLES[ind] = [int(col[2]) - 1, int(col[3]) - 1, int(col[4]) - 1 ]
            
            k_o = int(col[2])
            i_o = int(col[3])
            j_o = int(col[4])
            
            if( cnt_Angles >=  n_angles ):
                read_Angles = 0

            if( angles_overwrite ):
                angleObj = strucC.angleC[cnt_Angles]
                angleObj.pgid1 = k_o
                angleObj.pgid2 = i_o
                angleObj.pgid3 = j_o
                angleObj.set_lmpindx(int(col[1] ))
            else:
                angleObj = Angle( k_o,i_o, j_o )
                angleObj.set_lmpindx(int(col[1] ))
                strucC.angleC.put(angleObj)
            
                
            
        if(read_Dihedrals and len(col) >= 6 ):
            cnt_Dihedrals += 1
            ind = int( col[0]) - 1
            
            DTYPE_IND[ind] = int(col[1] ) - 1
            DIH[ind] = [int(col[2]) - 1,int(col[3]) - 1, int(col[4]) - 1,int(col[5]) - 1]

            k_o = int(col[2])
            i_o = int(col[3])
            j_o = int(col[4])
            l_o = int(col[5])
            
            if( dih_overwrite ):
                dObj = strucC.dihC[cnt_Dihedrals]
                dObj.pgid1 = k_o
                dObj.pgid2 = i_o
                dObj.pgid3 = j_o
                dObj.pgid4 = l_o
                dObj.set_lmpindx(int(col[1] ))
            else:
                dObj = Dihedral( k_o,i_o, j_o,l_o )
                dObj.set_lmpindx(int(col[1] ))
                strucC.dihC.put(dObj)
                
            if( cnt_Dihedrals >=  n_dihedrals ):
                read_Dihedrals = 0
                
            
        if(read_Impropers and len(col) >= 2 ):
            cnt_Impropers += 1
            ind = int( col[0]) - 1
            
            k_o = int(col[2])
            i_o = int(col[3])
            j_o = int(col[4])
            l_o = int(col[5])
            
            if( imp_overwrite ):
                impObj = strucC.impC[cnt_Impropers]
                impObj.pgid1 = k_o
                impObj.pgid2 = i_o
                impObj.pgid3 = j_o
                impObj.pgid4 = l_o
                impObj.set_lmpindx(int(col[1] ))
                impObj.set_type("improper")
            else:
                impObj = Improper( k_o,i_o, j_o,l_o )
                impObj.set_lmpindx(int(col[1] ))
                impObj.set_type("improper")
                strucC.impC.put(impObj)
                

            if( cnt_Impropers >=  n_impropers ):
                read_Impropers = 0

        if ( len(col) >= 1  ):
            if( col[0] == "Masses" ):
                read_Masses = 1
                cnt_Masses = 0
                
            if( col[0] == "Atoms" ):
                read_Atoms = 1
                cnt_Atoms = 0
                
            if( col[0] == "Bonds" ):
                read_Bonds = 1
                cnt_Bonds = 0
                
            if( col[0] == "Angles" ):
                read_Angles = 1
                cnt_Angles  = 0
                
            if( col[0] == "Dihedrals" ):
                read_Dihedrals = 1
                cnt_Dihedrals = 0
                
            if( col[0] == "Impropers" ):
                read_Impropers = 1
                cnt_Impropers = 0
                
        if ( len(col) >= 2 ):
            if( col[0] == "Pair" and col[1] == "Coeffs" ):
                read_Pair = 1
                cnt_Pair = 0
            if( col[0] == "Bond" and col[1] == "Coeffs" ):
                read_Bond_coeff = 1
                cnt_Bond_coeff = 0
            if( col[0] == "Angle" and col[1] == "Coeffs" ):
                read_Angle_coeff  = 1
                cnt_Angle_coeff = 0
            if( col[0] == "Dihedral" and col[1] == "Coeffs" ):
                read_Dihedral_coeff  = 1
                cnt_Dihedral_coeff  = 0
                
            if( col[0] == "Improper" and col[1] == "Coeffs" ):
                read_Improper_coeff  = 1
                cnt_Improper_coeff  = 0
                            
        #    cnt_Bonds += 1
        #    ind = int( col[0]) - 1
        #    BTYPE_IND[ind] = int(col[1] ) - 1
        #    BONDS[ind][0] = int(col[2])
        #    if( cnt_Bonds >=  n_atoms ):
        #        read_Bonds = 0
        #        
            

                #
    if( ljtyp_update ):
        if( ljtyp_cnt != len(parmC.ljtypC) ):
            print " Number of LJ types read in %d does not match previously read %d "%(ljtyp_cnt,len(parmC.ljtypC))

    if( debug):
        for ind in range(len(ATYPE_MASS)):
            print ind+1,ATYPE_MASS[ind]
            
        for ind in range(len(ATYPE_EP)):
            print ind+1,ATYPE_EP[ind],ATYPE_SIG[ind]
        
        for ind in range(n_btypes):
            print ind+1,BONDTYPE_R0[ind],BONDTYPE_K[ind]
                
        for ind in range(n_angtypes):
            print ind+1,ANGLETYPE_R0[ind],ANGLETYPE_K[ind]
        
        for ind in range(n_dtypes):
            print ind+1,DIHTYPE_C[ind]
        
    debug =0
    
    if( debug):
        for ind in range(len(BONDS)):
            print ind+1,BONDS[ind]
            
    if(debug):
        sys.exit("debug 1 ")
    #
    #      
    return (strucC,parmC)
Exemple #26
0
def main():
    """
    This test shows compressing IDs when structureContainer has angles included
    """

    p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
    p2 = Particle([2.2, 2.2, 2.2], "Si", 1.0, 2.34)
    p3 = Particle([3.3, 3.3, 3.3], "Si", 1.0, 2.34)
    p4 = Particle([0.0, 0.0, 0.0], "Si", 1.0, 2.34)
    #
    p5 = Particle([4.4, 4.4, 4.4], "C", 1.0, 2.34)  # 1
    p6 = Particle([5.5, 5.5, 5.5], "C", 1.0, 2.34)  # 2
    p7 = Particle([6.6, 6.6, 6.6], "C", 1.0, 2.34)  # 3

    b1 = Bond(1, 3, 1.11, "hooke")
    b2 = Bond(3, 4, 2.22, "hooke")
    #
    b3 = Bond(1, 2, 3.33, "hooke")
    b4 = Bond(2, 3, 4.44, "hooke")

    a1 = Angle(1, 3, 4, 1.11, "harmonic")
    #
    a2 = Angle(1, 2, 3, 2.22, "harmonic")

    atoms1 = ParticleContainer()
    atoms2 = ParticleContainer()
    atoms1.put(p1)
    atoms1.put(p2)
    atoms1.put(p3)
    atoms1.put(p4)
    #
    atoms2.put(p5)
    atoms2.put(p6)
    atoms2.put(p7)

    del atoms1[2]  # remove 2nd particle so ID's are non-consecutive

    bonds1 = BondContainer()
    bonds2 = BondContainer()
    bonds1.put(b1)
    bonds1.put(b2)
    bonds2.put(b3)
    bonds2.put(b4)

    angles1 = AngleContainer()
    angles2 = AngleContainer()
    angles1.put(a1)
    angles2.put(a2)

    polymer1 = StructureContainer(atoms1, bonds1, angles1)
    polymer2 = StructureContainer(atoms2, bonds2, angles2)

    del p1, p2, p3, p4, p5, p6, b1, b2, b3, b4, a1, a2
    del atoms1, atoms2, bonds1, bonds2, angles1, angles2
    print "\n Cleaning memory for initial objects \n"

    print "-------------------- Initial structures --------------------"
    print "polymer1 = ", polymer1
    print "polymer2 = ", polymer2
    print " "

    print "-------------- After adding  (polymer2 += polymer1) ----------------"
    polymer2 += polymer1
    print "polymer2 = ", polymer2

    polymer2.compressPtclIDs()

    print "-------------------- After compressing --------------------"
    print "polymer2 = ", polymer2
Exemple #27
0
import stellariumConnect, datetime, math
from angles import Angle 
from twoStarCalibrate import twoStarCalibrate
import numpy as np
from configParser import calibrationParser

stel1 = [Angle(r=1.6666*math.pi),Angle(r=math.pi/4)]
stel2 = [Angle(r=-math.pi/1.1),Angle(r=math.pi/52)]

tel1 = [Angle(r= -2.084132566391469),Angle(r= 0.785398163397448)]
tel2 = [Angle(r= 2.390466410049688),Angle(r= 0.060415243338265)]

TSC = twoStarCalibrate()
TSC.addStar(tel1, stel1)
TSC.addStar(tel2, stel2)

R = TSC.twoStarRotationMatrix()
R1 = TSC.oneStarRotaionMatrix()

TSC.addRotationMatrix(R)

[Az2,Alt2] = TSC.correct(-3.036725575684632, 0.300000000000000)

calP = calibrationParser("instrumentCalibration.xml")
calP.setAzAltCorrection(R)

Rp = calP.getAzAltCorrection()
print Rp
print R
print [Az2,Alt2]
Exemple #28
0
    def game_loop(self):

        global x, y, font, text, screen

        def clear():
            screen.fill(BLACK)

        pygame.init()

        x = gtk.gdk.screen_width()
        y = gtk.gdk.screen_height() - 55

        half_x = x / 2
        half_y = y / 2

        screen = pygame.display.get_surface()
        angleDisplay = screen.subsurface(
            (x * .18, y * .1, x - (2 * x * .18), y - (2 * y * .1)))
        self.planetNear = Image(
            PLANET_PREFIX + str(randint(0, PLANET_NUMBER - 1)) + PLANET_SUFFIX,
            screen)
        self.planetFar = Image(
            PLANET_PREFIX + str(randint(0, PLANET_NUMBER - 1)) + PLANET_SUFFIX,
            angleDisplay)

        # This is what a clicked button will call. so handle an answer here
        def saveAnswer(answer):
            # fill with black to wipe the screen. Otherwise the answer labels stack on each other
            # We wont need this when we are not outputting the answer.
            if (angle.checkAnswer(answer)):
                print('correct')

                score.increment()
                angle.setRandomAngle()
                print self.planetNear.image
                self.planetNear.originalImage = self.planetFar.originalImage
                self.planetFar = Image(
                    PLANET_PREFIX + str(randint(0, PLANET_NUMBER - 1)) +
                    PLANET_SUFFIX, angleDisplay)
                putPlanets(self.planetNear, self.planetFar)

            else:
                print('wrong')
                loseGame('')
                score.reset()

        def startGame(msg):
            global state
            state = GAME
            screen.fill(BLACK)

        def loseGame(msg):
            global state
            state = OVER
            clear()

        def mainMenu(msg):
            global state
            state = MAIN
            clear()

        def putPlanets(near, far):
            near.setSize(x * NEAR_SIZE, x * NEAR_SIZE)
            near.move(half_x, half_y)
            near.rect.center = near.rect.topleft

            far.setSize(x * FAR_SIZE, x * FAR_SIZE)
            far.move(angle.top[0], angle.top[1])
            far.rect.center = far.rect.topleft

        pygame.display.set_caption('Angles')

        font = pygame.font.SysFont(None, 48)
        smallFont = pygame.font.SysFont(None, 30)

        clock = pygame.time.Clock()

        scoreDisplay = screen.subsurface(
            (x * SCORE_X, y * SCORE_Y, x - (x * SCORE_X), y - (y * SCORE_Y)))

        angle = Angle(angleDisplay, 150, _ypercent=.3)

        tux = Image(TUX_IMAGE, screen)
        tux.move(half_x, half_y)
        tux.rect.midbottom = tux.rect.topleft

        putPlanets(self.planetNear, self.planetFar)

        score = ScoreTicker(x, y, scoreDisplay)

        but_half = (x * BUT_W / 2)

        rightBut = Button("Right", x * B1_X, y * B1_Y, x * BUT_W, y * BUT_H,
                          screen, saveAnswer)
        acuteBut = Button("Acute", x * B2_X, y * B2_Y, x * BUT_W, y * BUT_H,
                          screen, saveAnswer)
        obtBut = Button("Obtuse", x * B3_X, y * B3_Y, x * BUT_W, y * BUT_H,
                        screen, saveAnswer)

        #Game State Stuff
        startBut = Button("Start", (x * B4_X) - but_half, y * B4_Y, x * BUT_W,
                          y * BUT_H, screen, startGame)
        mainBut = Button("Menu", (x * B5_X) - but_half, y * B5_Y, x * BUT_W,
                         y * BUT_H, screen, mainMenu)
        restartBut = Button("Restart", (x * B6_X) - but_half, y * B6_Y,
                            x * BUT_W, y * BUT_H, screen, startGame)

        mainText = font.render("Tux Explorer", True, WHITE, BLACK)
        mainHalfWidth = mainText.get_width() / 2
        main_xpos = half_x - mainHalfWidth
        main_ypos = MAIN_Y * y

        helpText1 = smallFont.render(
            "Tux is lost! Help him navigate through space.", True, WHITE,
            BLACK)
        help1_xpos = half_x - (helpText1.get_width() / 2)
        help1_ypos = HELP1_Y * y

        helpText2 = smallFont.render(
            "Tell him if his angle to the next planet is acute, obtuse, or right.",
            True, WHITE, BLACK)
        help2_xpos = half_x - (helpText2.get_width() / 2)
        help2_ypos = HELP2_Y * y

        overText = font.render("Game Over!", True, WHITE, BLACK)
        overHalfWidth = overText.get_width() / 2
        over_xpos = half_x - overHalfWidth
        over_ypos = OVER_Y * y

        global state
        state = MAIN

        while 1:
            while gtk.events_pending():
                gtk.main_iteration()

            clicked = False
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    # Change "Juego Finalizado" to change the exit message (log)
                    score.saveScore()

                    exit("Game Finalized")
                elif event.type == pygame.VIDEORESIZE:
                    pygame.display.set_mode(event.size, pygame.RESIZABLE)
                elif event.type == pygame.MOUSEBUTTONUP:
                    clicked = True

            if state == MAIN:
                screen.blit(mainText, (main_xpos, main_ypos))
                screen.blit(helpText1, (help1_xpos, help1_ypos))
                screen.blit(helpText2, (help2_xpos, help2_ypos))
                startBut.draw(clicked)

            elif state == GAME:
                obtBut.draw(clicked)
                acuteBut.draw(clicked)
                rightBut.draw(clicked)

                score.draw()

                angle.draw()
                self.planetNear.draw()
                tux.draw()
                self.planetFar.draw()

            else:
                screen.fill(BLACK)
                screen.blit(overText, (over_xpos, over_ypos))
                mainBut.draw(clicked)
                restartBut.draw(clicked)

            pygame.display.flip()

            # Try to stay at 30 FPS
            clock.tick(30)
Exemple #29
0
def loadCoordsFile(fileName, clmsSpecification, dlm=','):
    """
    This function loads a file that contains points along with their
    respective coordinates. A sample row of this file may have the
    following format:
    p4,4478329.405,1921444.508,4101378.606, 41.464, 42.651
    where each delimited value corresponds to:
    id, E/X/lat, N/Y/lon, U/Z/h, geoidHeight, GMHeight respectively.
    and
    id: point id
    ENU: map coordinates
    XYZ: ECEF coordinates
    latlonh: geodetic coordinates
    geoidHeight: geoid undulation, i.e. geoidHeight = h - U
    GMHeight: geoid undulation coming from a geopotential model as EGM08

    * All coordinates values expressed in meters, except lat, lon where their
      values could be radians or degrees in the following formats:
      decimal degrees-dd, e.g. -0.1927322, degrees:minutes-dm, e.g. 11:2.3474,
      degrees:minutes:seconds-dms, e.g. -0:59:59.0001123

    Arguments
        fileName: string that specifies the name of file to be loaded
        clmsSpecification: list of strings, that specifies what each column
                           represent and in what order the columns are layout.
                           possible list any subset of:
                           ['id', 'X', 'Y', 'Z', lat-r/dd/dm/dms,
                           lon-r/dd/dm/dms, h, E, N, U, 'geoidHeight',
                           'GMHeight']
                           e.g. ['id', 'X', 'Y', 'Z'] or
                                ['id', 'Z', 'Y', 'X', 'geoidHeight']

                            lat-r/dd/dm/dms means that it could be
                            lat-r or lat-dd or lat-dm or lat-dms. The same
                            holds for lon-r/dd/dm/dms
        dlm: one character string that specifies file's delimiter
             e.g. ' ', ',', '\t'
    Returns
        any possible subset (concerning keys) of the follwoing dictionary:
        {'id': [strings], 'X': [numbers], 'Y': [numbers], 'Z': [numbers],
        'lat-r/dd/dm/dms': [numbers/strings],
        'lon-r/dd/dm/dms': [numbers/strings], 'h': [numbers], 'E': [numbers],
        'N': [numbers], 'U': [numbers]
        'geoidHeight': [numbers], 'GMHeight': [numbers]}
    """
    if len(set(clmsSpecification)) != len(clmsSpecification):
        raise Exception("Your columns specification contain duplicates")
    allClms = {'id', 'X', 'Y', 'Z', 'lat-r', 'lon-r', 'lat-dd', 'lon-dd',
               'lat-dm', 'lon-dm', 'lat-dms', 'lon-dms', 'h', 'E', 'N', 'U',
               'geoidHeight', 'GMHeight'}
    if not set(clmsSpecification).issubset(allClms):
        raise Exception("Define columns specification properly")

    with open(fileName) as fObj:
        readCSV = reader(fObj, delimiter=dlm)
        data = defaultdict(list)
        for line in readCSV:
            if line:
                for key, value in zip(clmsSpecification, line):
                    data[key].append(value.strip())
        latlonInDeg = ['lat-dd', 'lon-dd', 'lat-dm', 'lon-dm',
                       'lat-dms', 'lon-dms']
        for key in set(data.keys()) - {'id'}:
            # if key not in latlonInDeg:
            #     data[key] = [float(x) for x in data[key]]
            if key in ['lat-r', 'lon-r']:
                data[key] = [Angle(float(x)) for x in data[key]]
            elif key in latlonInDeg:
                data[key] = [Angle(x) for x in data[key]]
            else:
                data[key] = [float(x) for x in data[key]]
        return data
Exemple #30
0
def read_lmpdata(strucC, parmC, data_file):
    """
    Read Lammps data file


    Arguments:
        strucC     (StructureContainer)
        parmC      (ParameterContainer)
        data_file  (str) data file
    
    ReturnS:
        strucC     (StructureContainer)
        parmC      (ParameterContainer)
    
    """

    debug = 0
    verbose = True

    set_chain_numbers = True

    if (not set_chain_numbers):
        print " Warning not reading in chain numbers!!! "

    # Load periodic table
    pt = periodictable()

    F = open(data_file, 'r')
    lines = F.readlines()
    F.close()

    #
    # Read in data header with number of parameters
    #
    for line in lines:
        col = line.split()
        if (len(col) >= 2):
            # Read in number of each topolgical component
            if (col[1] == "atoms"):
                n_atoms = int(col[0])
            elif (col[1] == "bonds"):
                n_bonds = int(col[0])
            elif (col[1] == "angles"):
                n_angles = int(col[0])
            elif (col[1] == "dihedrals"):
                n_dihedrals = int(col[0])
            elif (col[1] == "impropers"):
                n_impropers = int(col[0])

        if (len(col) >= 3):
            # Read in number of each parameter type
            if (col[1] == "atom" and col[2] == "types"):
                n_atypes = int(col[0])
            elif (col[1] == "bond" and col[2] == "types"):
                n_btypes = int(col[0])
            elif (col[1] == "angle" and col[2] == "types"):
                n_angtypes = int(col[0])
            elif (col[1] == "dihedral" and col[2] == "types"):
                n_dtypes = int(col[0])
            elif (col[1] == "improper" and col[2] == "types"):
                n_imptypes = int(col[0])

        # Read in box size
        if (len(col) >= 4):
            if (col[2] == "xlo" and col[3] == "xhi"):
                strucC.latvec[0][0] = float(col[1]) - float(col[0])
            if (col[2] == "ylo" and col[3] == "yhi"):
                strucC.latvec[1][1] = float(col[1]) - float(col[0])
            if (col[2] == "zlo" and col[3] == "zhi"):
                strucC.latvec[2][2] = float(col[1]) - float(col[0])

    # Prind debug
    if (verbose):
        print " atoms ", n_atoms
        print " n_bonds ", n_bonds
        print " n_angles ", n_angles
        print " n_dihedrals ", n_dihedrals
        print " n_impropers ", n_impropers
        print ""
        print "n_atom_types", n_atypes
        print "n_bond_types", n_btypes
        print "n_angle_types", n_angtypes
        print "n_dihedral_types", n_dtypes
        print "n_imp_dihedral_types", n_imptypes

    # Check to see if a previous read has occured
    pt_overwrite = False
    if (len(strucC.ptclC) > 0):
        pt_overwrite = True
    # Check of conistent number of atoms
    if (pt_overwrite):
        if (len(strucC.ptclC) != n_atoms):
            print "  %d atoms in passed structure " % (len(strucC.ptclC))
            print "  %d atoms in data file " % (n_atoms)
            sys.exit(" Inconsistent number of atoms ")

    else:
        #
        # Initialize particle container
        #
        for pid_i in range(n_atoms):
            pt_i = Particle()
            strucC.ptclC.put(pt_i)

    bonds_overwrite = False
    if (len(strucC.bondC) > 0):
        bonds_overwrite = True

        if (len(strucC.bondC) != n_bonds):
            print "  %d bonds in passed structure " % (len(strucC.bondC))
            print "  %d bonds in data file " % (n_bonds)
            sys.exit(" Inconsistent number of bonds ")

    angles_overwrite = False
    if (len(strucC.angleC) > 0):
        angles_overwrite = True
        if (len(strucC.angleC) != n_angles):
            print "  %d angles in passed structure " % (len(strucC.angleC))
            print "  %d angles in data file " % (n_angles)
            sys.exit(" Inconsistent number of angles ")

    dih_overwrite = False
    if (len(strucC.dihC) > 0):
        dih_overwrite = True
        if (len(strucC.dihC) != n_dihedrals):
            print "  %d dihedrals in passed structure " % (len(strucC.dihC))
            print "  %d dihedrals in data file " % (n_dihedrals)
            sys.exit(" Inconsistent number of dihedrals ")

    imp_overwrite = False
    if (len(strucC.impC) > 0):
        imp_overwrite = True
        if (len(strucC.impC) != n_impropers):
            print "  %d impropers in passed structure " % (len(strucC.impC))
            print "  %d impropers in data file " % (n_impropers)
            sys.exit(" Inconsistent number of impropers ")

    #
    # Intialize
    #   - read in boolean to off
    #
    read_Masses = 0
    read_Pair = 0
    read_Bond_coeff = 0
    read_Angle_coeff = 0
    read_Dihedral_coeff = 0
    read_Improper_coeff = 0

    read_Atoms = 0
    read_Bonds = 0
    read_Angles = 0
    read_Dihedrals = 0
    read_Impropers = 0

    #   - lists as indecise can be out of order in data file
    ATYPE_REF = n_atypes * [""]
    ATYPE_MASS = np.zeros(n_atypes)
    ATYPE_EP = np.zeros(n_atypes)
    ATYPE_SIG = np.zeros(n_atypes)

    BTYPE_REF = n_btypes * [2 * [""]]
    BONDTYPE_R0 = np.zeros(n_btypes)
    BONDTYPE_K = np.zeros(n_btypes)

    ANGTYPE_REF = n_angtypes * [3 * [""]]
    ANGLETYPE_R0 = np.zeros(n_angtypes)
    ANGLETYPE_K = np.zeros(n_angtypes)

    DTYPE_REF = n_dtypes * [4 * [""]]
    DIHTYPE_C = np.zeros((n_dtypes, 4))
    DIHTYPE_F = np.zeros(n_dtypes)
    DIHTYPE_K = np.zeros(n_dtypes)
    DIHTYPE_PN = np.zeros(n_dtypes)
    DIHTYPE_PHASE = np.zeros(n_dtypes)

    IMPTYPE_REF = n_imptypes * [4 * [""]]
    IMPTYPE_F = np.zeros(n_imptypes)
    IMPTYPE_E0 = np.zeros(n_imptypes)
    IMPTYPE_K = np.zeros(n_imptypes)

    MOLNUMB = n_atoms * [0]
    ATYPE_IND = n_atoms * [0]
    CHARGES = np.zeros(n_atoms)
    R = n_atoms * [np.zeros(3)]
    ATYPE = n_atoms * [""]

    BONDS = n_bonds * [[0, 0]]
    BTYPE_IND = n_bonds * [0]

    ANGLES = n_angles * [[0, 0, 0]]
    ANGTYPE_IND = n_angles * [0]

    DIH = n_dihedrals * [[0, 0, 0, 0]]
    DTYPE_IND = n_dihedrals * [0]

    #
    # Check if values exist and need to be updated or don't and need to be created
    #
    ljtyp_update = False
    ljtyp_cnt = 0
    if (len(parmC.ljtypC) > 0):
        print " LJ types will be updated "
        ljtyp_update = True
    btyp_update = False
    btyp_cnt = 0
    if (len(parmC.btypC) > 0):
        print " Bond types will be updated "
        btyp_update = True
    atyp_update = False
    atyp_cnt = 0
    if (len(parmC.atypC) > 0):
        print " Angle types will be updated "
        atyp_update = True
    dtyp_update = False
    dtyp_cnt = 0
    if (len(parmC.dtypC) > 0):
        print " Dihedral types will be updated "
        dtyp_update = True
    imptyp_update = False
    imptyp_cnt = 0
    if (len(parmC.imptypC) > 0):
        print " Improper dihedrals types will be updated "
        imptyp_update = True
    #
    # Read in data parameters
    #

    for line in lines:
        col = line.split()
        if (read_Masses and len(col) >= 2):

            cnt_Masses += 1
            ind = int(col[0]) - 1
            ATYPE_MASS[ind] = float(col[1])

            if (len(col) >= 4):
                ATYPE_REF[ind] = col[3]
                ptype1 = col[3]
            else:
                ATYPE_REF[ind] = "??"
                ptype1 = "??"

            mass_i = float(col[1])

            if (ljtyp_update):
                ljtyp_cnt = ind + 1
                if (ljtyp_cnt > len(parmC.ljtypC)):
                    print "Mass index %d larger then length of previously read ljtypC %d" % (
                        ind, len(parmC.ljtypC))
                ljtyp_i = parmC.ljtypC[ljtyp_cnt]
                ljtyp_i.setmass(mass_i)
            else:
                ljtyp_i = ljtype(ptype1)
                ljtyp_i.setmass(mass_i)
                parmC.ljtypC.put(ljtyp_i)

            # Turn of mass read
            if (cnt_Masses == n_atypes):
                read_Masses = 0

        if (read_Pair and len(col) >= 3):
            cnt_Pair += 1

            ind = int(col[0]) - 1
            ATYPE_EP[ind] = float(col[1])
            ATYPE_SIG[ind] = float(col[2])

            epsilon = float(col[1])
            sigma = float(col[2])
            ljtyp_ind = int(col[0])

            ljtyp_i = parmC.ljtypC[ljtyp_ind]
            ljtyp_i.setparam(epsilon, sigma)
            # Turn pair parameter read off
            if (cnt_Pair >= n_atypes):
                read_Pair = 0

        if (read_Bond_coeff and len(col) >= 3):
            cnt_Bond_coeff += 1
            #AT_i = int(col[0])
            #AT_j = int(col[1])
            b_ind = int(col[0]) - 1
            if (b_ind > n_btypes):
                error_line = " Error in data file index of bond parameter exceeds number of bond parameters specified with bond types "
                sys.exit(error_line)

            BTYPE_REF[b_ind][0] = "??"
            BTYPE_REF[b_ind][1] = "??"
            BONDTYPE_K[b_ind] = float(col[1])
            BONDTYPE_R0[b_ind] = float(col[2])

            ptype1 = "??"
            ptype2 = "??"
            lmpindx = int(col[0])
            kb = float(col[1])
            r0 = float(col[2])
            btype = "harmonic"
            g_type = 1

            if (btyp_update):
                btyp_cnt = b_ind + 1
                btyp_i = parmC.btypC[btyp_cnt]
                btyp_i.setharmonic(r0, kb)
                btyp_i.set_g_indx(g_type)
                btyp_i.set_lmpindx(lmpindx)
            else:
                btyp_i = bondtype(ptype1, ptype2, btype)
                btyp_i.setharmonic(r0, kb)
                btyp_i.set_g_indx(g_type)
                btyp_i.set_lmpindx(lmpindx)
                parmC.btypC.put(btyp_i)

            if (cnt_Bond_coeff >= n_btypes):
                read_Bond_coeff = 0

        if (read_Angle_coeff and len(col) >= 3):
            cnt_Angle_coeff += 1
            #AT_i = int(col[0])
            #AT_j = int(col[1])
            a_ind = int(col[0]) - 1
            if (a_ind > n_angtypes):
                print sys.exit(
                    " Error in data file index of angle parameter exceeds number of angle parameters specified with angle types "
                )

            ANGTYPE_REF[a_ind][0] = "??"
            ANGTYPE_REF[a_ind][1] = "??"
            ANGTYPE_REF[a_ind][2] = "??"
            ANGLETYPE_K[a_ind] = float(col[1])
            ANGLETYPE_R0[a_ind] = float(col[2])

            ptype1 = "??"
            ptype2 = "??"
            ptype3 = "??"
            lmpindx = int(col[0])
            theta0 = float(col[2])  # degrees
            kb = float(col[1])
            atype = "harmonic"
            gfunc_type = 1

            if (atyp_update):
                atyp_cnt = a_ind + 1
                atyp_i = parmC.atypC[atyp_cnt]
                atyp_i.set_g_indx(gfunc_type)
                atyp_i.set_lmpindx(lmpindx)
                atyp_i.setharmonic(theta0, kb)
            else:
                atyp_i = angletype(ptype1, ptype2, ptype3, atype)
                atyp_i.set_g_indx(gfunc_type)
                atyp_i.set_lmpindx(lmpindx)
                atyp_i.setharmonic(theta0, kb)
                parmC.atypC.put(atyp_i)

            if (cnt_Angle_coeff >= n_angtypes):
                read_Angle_coeff = 0

        if (read_Dihedral_coeff and len(col) >= 3):
            cnt_Dihedral_coeff += 1
            #AT_i = int(col[0])
            #AT_j = int(col[1])
            d_ind = int(col[0]) - 1

            if (debug):
                print " reading dih type ", d_ind, " cnt ", cnt_Dihedral_coeff, " of ", n_dtypes

            if (d_ind > n_dtypes):
                error_line = " Error in data file index of dihedral parameter %d exceeds number of dihedral parameters %d " % (
                    d_ind, n_dtypes)
                error_line += " specified with dihedral types "
                print sys.exit(error_line)

            DTYPE_REF[d_ind][0] = "??"
            DTYPE_REF[d_ind][1] = "??"
            DTYPE_REF[d_ind][2] = "??"
            DTYPE_REF[d_ind][3] = "??"

            # Assume OPLS dihedral type
            DIHTYPE_F[d_ind] = 3
            DIHTYPE_C[d_ind][0] = float(col[1])
            DIHTYPE_C[d_ind][1] = float(col[2])
            DIHTYPE_C[d_ind][2] = float(col[3])
            DIHTYPE_C[d_ind][3] = float(col[4])

            ptype1 = "??"
            ptype2 = "??"
            ptype3 = "??"
            ptype4 = "??"
            # Set parameters according to type
            gfunc_type = 3
            dtype = "opls"

            lmpindx = int(col[0])
            k1 = float(col[1])
            k2 = float(col[2])
            k3 = float(col[3])
            k4 = float(col[4])

            if (dtyp_update):
                dtyp_cnt = d_ind + 1
                dtyp_i = parmC.dtypC[dtyp_cnt]
                dtyp_i.set_g_indx(gfunc_type)
                dtyp_i.set_lmpindx(lmpindx)
                dtyp_i.setopls(k1, k2, k3, k4)
            else:
                dtyp_i = dihtype(ptype1, ptype2, ptype3, ptype4, dtype)
                dtyp_i.set_g_indx(gfunc_type)
                dtyp_i.set_lmpindx(lmpindx)
                dtyp_i.setopls(k1, k2, k3, k4)
                parmC.dtypC.put(dtyp_i)

            if (cnt_Dihedral_coeff >= n_dtypes):
                read_Dihedral_coeff = 0

        if (read_Improper_coeff and len(col) >= 3):
            cnt_Improper_coeff += 1
            #AT_i = int(col[0])
            #AT_j = int(col[1])
            imp_ind = int(col[0]) - 1

            if (debug):
                print " reading imp dih type ", imp_ind, " cnt ", cnt_Improper_coeff, " of ", n_imptypes

            if (imp_ind > n_imptypes):
                error_line = " Error in data file index of improper parameter %d exceeds number of improper parameters %d " % (
                    imp_ind, n_imptypes)
                error_line += " specified with dihedral types "
                print sys.exit(error_line)

            IMPTYPE_REF[imp_ind][0] = "??"
            IMPTYPE_REF[imp_ind][1] = "??"
            IMPTYPE_REF[imp_ind][2] = "??"
            IMPTYPE_REF[imp_ind][3] = "??"

            # Assume OPLS dihedral type
            IMPTYPE_F[imp_ind] = 2
            KE = float(col[1])
            Eo = float(col[2])
            IMPTYPE_E0[imp_ind] = Eo
            IMPTYPE_K[imp_ind] = KE

            ptype1 = "??"
            ptype2 = "??"
            ptype3 = "??"
            ptype4 = "??"
            # Set parameters according to type
            g_indx = 2
            dtype = "improper"

            lmpindx = int(col[0])

            if (imptyp_update):
                imptyp_cnt = imp_ind + 1
                imptyp_i = parmC.imptypC[imptyp_cnt]
                imptyp_i.set_g_indx(g_indx)
                imptyp_i.setimp(Eo, KE)
                imptyp_i.set_lmpindx(lmpindx)
            else:
                imptyp_i = imptype(ptype1, ptype2, ptype3, ptype4, dtype)
                imptyp_i.set_g_indx(g_indx)
                imptyp_i.setimp(Eo, KE)
                imptyp_i.set_lmpindx(lmpindx)
                parmC.imptypC.put(imptyp_i)

            if (cnt_Improper_coeff >= n_imptypes):
                read_Improper_coeff = 0

        if (read_Atoms and len(col) >= 7):
            cnt_Atoms += 1
            ind = int(col[0]) - 1
            if (ind > n_atoms):
                print sys.exit(
                    " Error in data file index of atoms exceeds number of atoms specified with atoms "
                )

            chain_i = int(col[1])
            lmptype_i = int(col[2])  #- 1
            indx = int(col[2]) - 1
            q_i = float(col[3])
            m_i = ATYPE_MASS[indx]
            fftype_i = ATYPE_REF[indx]
            el = pt.getelementWithMass(m_i)

            if (el.symbol == "VS"):
                el.symbol = ATYPE_l[atom_indx].strip()
                fftype_i = "VS"
                m_i = 0.0

            # HACK !!
            if (ATYPE_MASS[indx] == 9.0):
                el.symbol = "LP"
                fftype_i = "LP"
                m_i = 0.0

            r_i = [float(col[4]), float(col[5]), float(col[6])]
            type_i = str(lmptype_i)

            #tagsD = {"chain":chain_i,"symbol":el.symbol,"number":el.number,"mass":el.mass,"cov_radii":el.cov_radii,"vdw_radii":el.vdw_radii}
            #if( pt_overwrite ):
            pt_i = strucC.ptclC[ind + 1]
            pt_i.position = r_i
            pt_i.charge = q_i
            pt_i.mass = m_i

            add_dict = pt_i.tagsDict
            # Set properties read in data file
            if (set_chain_numbers): add_dict["chain"] = chain_i
            add_dict["symbol"] = el.symbol
            add_dict["number"] = el.number
            add_dict["mass"] = el.mass
            add_dict["cov_radii"] = el.cov_radii
            add_dict["vdw_radii"] = el.vdw_radii
            add_dict["lmptype"] = lmptype_i
            add_dict["fftype"] = fftype_i
            #
            add_dict["ffmass"] = ATYPE_MASS[indx]
            pt_i.setTagsDict(add_dict)

            if (cnt_Atoms >= n_atoms):
                read_Atoms = 0

        if (read_Bonds and len(col) >= 4):
            cnt_Bonds += 1
            ind = int(col[0]) - 1

            if (ind > n_bonds):
                print sys.exit(
                    " Error in data file index of bonds exceeds number of bonds specified with bonds "
                )

            BTYPE_IND[ind] = int(col[1]) - 1
            BONDS[ind] = [int(col[2]) - 1, int(col[3]) - 1]
            i_o = int(col[2])
            j_o = int(col[3])

            if (bonds_overwrite):
                bondObj = strucC.bondC[cnt_Bonds]
                bondObj.pgid1 = i_o
                bondObj.pgid2 = j_o
                bondObj.set_lmpindx(int(col[1]))
            else:
                bondObj = Bond(i_o, j_o)
                bondObj.set_lmpindx(int(col[1]))
                strucC.bondC.put(bondObj)

            if (cnt_Bonds >= n_bonds):
                read_Bonds = 0

        if (read_Angles and len(col) >= 5):
            cnt_Angles += 1
            ind = int(col[0]) - 1
            ANGTYPE_IND[ind] = int(col[1]) - 1
            ANGLES[ind] = [int(col[2]) - 1, int(col[3]) - 1, int(col[4]) - 1]

            k_o = int(col[2])
            i_o = int(col[3])
            j_o = int(col[4])

            if (cnt_Angles >= n_angles):
                read_Angles = 0

            if (angles_overwrite):
                angleObj = strucC.angleC[cnt_Angles]
                angleObj.pgid1 = k_o
                angleObj.pgid2 = i_o
                angleObj.pgid3 = j_o
                angleObj.set_lmpindx(int(col[1]))
            else:
                angleObj = Angle(k_o, i_o, j_o)
                angleObj.set_lmpindx(int(col[1]))
                strucC.angleC.put(angleObj)

        if (read_Dihedrals and len(col) >= 6):
            cnt_Dihedrals += 1
            ind = int(col[0]) - 1

            DTYPE_IND[ind] = int(col[1]) - 1
            DIH[ind] = [
                int(col[2]) - 1,
                int(col[3]) - 1,
                int(col[4]) - 1,
                int(col[5]) - 1
            ]

            k_o = int(col[2])
            i_o = int(col[3])
            j_o = int(col[4])
            l_o = int(col[5])

            if (dih_overwrite):
                dObj = strucC.dihC[cnt_Dihedrals]
                dObj.pgid1 = k_o
                dObj.pgid2 = i_o
                dObj.pgid3 = j_o
                dObj.pgid4 = l_o
                dObj.set_lmpindx(int(col[1]))
            else:
                dObj = Dihedral(k_o, i_o, j_o, l_o)
                dObj.set_lmpindx(int(col[1]))
                strucC.dihC.put(dObj)

            if (cnt_Dihedrals >= n_dihedrals):
                read_Dihedrals = 0

        if (read_Impropers and len(col) >= 2):
            cnt_Impropers += 1
            ind = int(col[0]) - 1

            k_o = int(col[2])
            i_o = int(col[3])
            j_o = int(col[4])
            l_o = int(col[5])

            if (imp_overwrite):
                impObj = strucC.impC[cnt_Impropers]
                impObj.pgid1 = k_o
                impObj.pgid2 = i_o
                impObj.pgid3 = j_o
                impObj.pgid4 = l_o
                impObj.set_lmpindx(int(col[1]))
                impObj.set_type("improper")
            else:
                impObj = Improper(k_o, i_o, j_o, l_o)
                impObj.set_lmpindx(int(col[1]))
                impObj.set_type("improper")
                strucC.impC.put(impObj)

            if (cnt_Impropers >= n_impropers):
                read_Impropers = 0

        if (len(col) >= 1):
            if (col[0] == "Masses"):
                read_Masses = 1
                cnt_Masses = 0

            if (col[0] == "Atoms"):
                read_Atoms = 1
                cnt_Atoms = 0

            if (col[0] == "Bonds"):
                read_Bonds = 1
                cnt_Bonds = 0

            if (col[0] == "Angles"):
                read_Angles = 1
                cnt_Angles = 0

            if (col[0] == "Dihedrals"):
                read_Dihedrals = 1
                cnt_Dihedrals = 0

            if (col[0] == "Impropers"):
                read_Impropers = 1
                cnt_Impropers = 0

        if (len(col) >= 2):
            if (col[0] == "Pair" and col[1] == "Coeffs"):
                read_Pair = 1
                cnt_Pair = 0
            if (col[0] == "Bond" and col[1] == "Coeffs"):
                read_Bond_coeff = 1
                cnt_Bond_coeff = 0
            if (col[0] == "Angle" and col[1] == "Coeffs"):
                read_Angle_coeff = 1
                cnt_Angle_coeff = 0
            if (col[0] == "Dihedral" and col[1] == "Coeffs"):
                read_Dihedral_coeff = 1
                cnt_Dihedral_coeff = 0

            if (col[0] == "Improper" and col[1] == "Coeffs"):
                read_Improper_coeff = 1
                cnt_Improper_coeff = 0

        #    cnt_Bonds += 1
        #    ind = int( col[0]) - 1
        #    BTYPE_IND[ind] = int(col[1] ) - 1
        #    BONDS[ind][0] = int(col[2])
        #    if( cnt_Bonds >=  n_atoms ):
        #        read_Bonds = 0
        #

        #
    if (ljtyp_update):
        if (ljtyp_cnt != len(parmC.ljtypC)):
            print " Number of LJ types read in %d does not match previously read %d " % (
                ljtyp_cnt, len(parmC.ljtypC))

    if (debug):
        for ind in range(len(ATYPE_MASS)):
            print ind + 1, ATYPE_MASS[ind]

        for ind in range(len(ATYPE_EP)):
            print ind + 1, ATYPE_EP[ind], ATYPE_SIG[ind]

        for ind in range(n_btypes):
            print ind + 1, BONDTYPE_R0[ind], BONDTYPE_K[ind]

        for ind in range(n_angtypes):
            print ind + 1, ANGLETYPE_R0[ind], ANGLETYPE_K[ind]

        for ind in range(n_dtypes):
            print ind + 1, DIHTYPE_C[ind]

    debug = 0

    if (debug):
        for ind in range(len(BONDS)):
            print ind + 1, BONDS[ind]

    if (debug):
        sys.exit("debug 1 ")
    #
    #
    return (strucC, parmC)
def main():
    """
    This test shows structureContainer functionality with dihedrals included
    """
    print "************************************************************************************"
    print " This test shows structureContainer functionality with dihedrals included"
    print "************************************************************************************ \n"

    p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
    p2 = Particle([2.2, 2.2, 2.2], "Si", 1.0, 2.34)
    p3 = Particle([3.3, 3.3, 3.3], "Si", 1.0, 2.34)
    p4 = Particle([4.4, 4.4, 4.4], "Si", 1.0, 2.34)
    #
    p5 = Particle([5.5, 5.5, 5.5], "C", 1.0, 2.34)  # 1
    p6 = Particle([6.6, 6.6, 6.6], "C", 1.0, 2.34)  # 2
    p7 = Particle([7.7, 7.7, 7.7], "C", 1.0, 2.34)  # 3
    p8 = Particle([8.8, 8.8, 8.8], "C", 1.0, 2.34)  # 4

    b1 = Bond(1, 2, 1.11, "hooke")
    b2 = Bond(2, 3, 2.22, "hooke")
    b3 = Bond(3, 4, 3.33, "hooke")
    #
    b4 = Bond(1, 2, 4.44, "hooke")
    b5 = Bond(2, 3, 5.55, "hooke")
    b6 = Bond(3, 4, 6.66, "hooke")

    a1 = Angle(1, 2, 3, 1.11, "harmonic")
    #
    a2 = Angle(1, 2, 3, 2.22, "harmonic")

    d1 = Dihedral(1, 2, 3, 4, 1.11, "stiff")
    #
    d2 = Dihedral(1, 2, 3, 4, 2.22, "stiff")

    atoms1 = ParticleContainer()
    atoms2 = ParticleContainer()
    atoms1.put(p1)
    atoms1.put(p2)
    atoms1.put(p3)
    atoms1.put(p4)
    #
    atoms2.put(p5)
    atoms2.put(p6)
    atoms2.put(p7)
    atoms2.put(p8)

    bonds1 = BondContainer()
    bonds2 = BondContainer()
    bonds1.put(b1)
    bonds1.put(b2)
    bonds1.put(b3)
    #
    bonds2.put(b4)
    bonds2.put(b5)
    bonds2.put(b6)

    angles1 = AngleContainer()
    angles2 = AngleContainer()
    angles1.put(a1)
    angles2.put(a2)

    dih1 = DihedralContainer()
    dih2 = DihedralContainer()
    dih1.put(d1)
    dih2.put(d2)

    polymer1 = StructureContainer(atoms1, bonds1, angles1, dih1)
    polymer2 = StructureContainer(atoms2, bonds2, angles2, dih2)

    del p1, p2, p3, p4, p5, p6, p7, p8
    del b1, b2, b3, b4, b5, b6, a1, a2, d1, d2
    del atoms1, atoms2, bonds1, bonds2, angles1, angles2, dih1, dih2
    print "\n Cleaning memory for initial objects \n"

    print "-------------------- Initial structures --------------------"
    print "polymer1 = ", polymer1
    print "polymer2 = ", polymer2
    print " "

    print "-------------- After adding  (polymer1 += polymer2) ----------------"
    polymer2 += polymer1
    print "polymer2 = ", polymer2
def main():

    """
    This test shows structureContainer functionality with angles included
    """    
    print "************************************************************************************"
    print " This test shows structureContainer functionality with angles included"
    print "************************************************************************************ \n"

    p1 = Particle( [1.1, 1.1, 1.1], "Si", 2.0, 1.23)
    p2 = Particle( [2.2, 2.2, 2.2], "Si",  1.0, 2.34)
    p3 = Particle( [3.3, 3.3, 3.3], "Si",  1.0, 2.34)
    #
    p4 = Particle( [4.4, 4.4, 4.4], "C",  1.0, 2.34)   # 1
    p5 = Particle( [5.5, 5.5, 5.5], "C",  1.0, 2.34)   # 2
    p6 = Particle( [6.6, 6.6, 6.6], "C",  1.0, 2.34)   # 3

    b1 = Bond( 1, 2, 1.11, "hooke")
    b2 = Bond( 2, 3, 2.22, "hooke")
    #
    b3 = Bond( 1, 2, 3.33, "hooke")
    b4 = Bond( 2, 3, 4.44, "hooke")

    a1 = Angle(1, 2, 3, 1.11, "harmonic")
    #
    a2 = Angle(1, 2, 3, 2.22, "harmonic")

    atoms1 = ParticleContainer()
    atoms2 = ParticleContainer()
    atoms1.put(p1)
    atoms1.put(p2)
    atoms1.put(p3)
    #
    atoms2.put(p4)
    atoms2.put(p5)
    atoms2.put(p6)

    bonds1 = BondContainer()
    bonds2 = BondContainer()
    bonds1.put(b1)
    bonds1.put(b2)
    bonds2.put(b3)
    bonds2.put(b4)

    angles1 = AngleContainer()
    angles2 = AngleContainer()
    angles1.put(a1)
    angles2.put(a2)

    polymer1 = StructureContainer(atoms1, bonds1, angles1)
    polymer2 = StructureContainer(atoms2, bonds2, angles2)


    del p1, p2, p3, p4, p5, p6, b1, b2, b3, b4, a1, a2
    del atoms1, atoms2, bonds1, bonds2, angles1, angles2
    print "\n Cleaning memory for initial objects \n" 

    print "-------------------- Initial structures --------------------"
    print "polymer1 = ", polymer1
    print "polymer2 = ", polymer2
    print " "

    print "-------------- After adding  (polymer1 += polymer2) ----------------"
    polymer2 += polymer1
    print "polymer2 = ", polymer2
Exemple #33
0
def main():
    """
    This test shows how to set up Structure container with Particle/Bond-Containers
    Shows how ID changed in Structure propagate to values set in BondContainer and
    and an AngleContainer for its held particle ID values
    Illustrates how a substructure method could return subgroup
    """

    print "************************************************************************************"
    print " This test shows how to set up Structure container with Particle/Bond-Containers \n"
    print " Shows how ID changed in Structure propagate to values set in BondContainer and "
    print " and an AngleContainer for its held particle ID values \n"
    print " Illustrates how a substructure method could return subgroup"
    print "************************************************************************************ \n"

    p1 = Particle([0.2, 1.3, 33.0], "Si", 2.0, 1.23)
    p2 = Particle([5.0, 2.3, -22.1], "C", 1.0, 2.34)
    p3 = Particle([5.0, 2.3, -20.1], "C", 1.0, 2.34)
    p4 = Particle([0.0, 2.3, -20.1], "C", 1.0, 2.34)
    p5 = Particle([0.2, 1.3, 33.0], "Si", 2.0, 1.23)

    b1 = Bond(5, 2, 1.233, "hooke")  # This setup mimics earlier state of test
    b2 = Bond(2, 3, 0.500, "hooke")  # Still matches with diagram
    b3 = Bond(3, 4, 2.301, "hooke")
    b4 = Bond(5, 3, 0.828, "hooke")

    a1 = Angle(1, 2, 3, 1.111, "harmonic")
    a2 = Angle(2, 3, 4, 2.222, "harmonic")

    atoms1 = ParticleContainer()
    atoms1.put(p1)
    atoms1.put(p2)
    atoms1.put(p3)
    atoms1.put(p4)
    atoms1.put(p5)

    del atoms1[1]  # This is to mimic state of container for an older test

    bonds = BondContainer()
    bonds.put(b1)
    bonds.put(b2)
    bonds.put(b3)
    bonds.put(b4)

    angles = AngleContainer()
    angles.put(a1)
    angles.put(a2)

    del p1, p2, p3, p4, b1, b2, b3, b4, a1, a2
    polymer1 = StructureContainer(atoms1, bonds, angles)
    del atoms1, bonds, angles

    print "********************************************************** \n"
    print polymer1
    print diagramAfter
    print "********************************************************** \n"

    print "-------------------------------------------------------------------------------- \n"

    print "********************************************************** \n"
    print "Testing polymer1.getSubStructure([5,2])"
    print "   currently ID's are reassigned in substructure \n"
    subpolymer = polymer1.getSubStructure([5, 2])
    print subpolymer
    print diagramAfter
    print "********************************************************** \n"

    print "********************************************************** \n"
    print "polymer1 Struture after returning sub-structure"
    print polymer1
    print "********************************************************** \n"

    print "-------------------------------------------------------------------------------- \n"

    print "********************************************************** \n"
    print "Testing polymer1.getSubStructure([2,3,4])"
    print "   currently ID's are reassigned in substructure \n"
    subpolymer = polymer1.getSubStructure([2, 3, 4])
    print subpolymer
    print diagramAfter
    print "********************************************************** \n"