ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/applications/staticProps/BondOrderParameter.cpp
(Generate patch)

Comparing trunk/OOPSE-4/src/applications/staticProps/BondOrderParameter.cpp (file contents):
Revision 3007 by gezelter, Tue Sep 19 21:14:11 2006 UTC vs.
Revision 3018 by gezelter, Fri Sep 22 01:41:11 2006 UTC

# Line 51 | Line 51
51   #include "io/DumpReader.hpp"
52   #include "primitives/Molecule.hpp"
53   #include "utils/NumericConstant.hpp"
54 < #include "math/RealSphericalHarmonic.hpp"
54 > #include "math/SphericalHarmonic.hpp"
55 >
56   namespace oopse {
57  
57 –
58    BondOrderParameter::BondOrderParameter(SimInfo* info,
59                                           const std::string& filename,
60                                           const std::string& sele,
61 <                                         double rCut, int lNumber, int nbins)
62 <    : StaticAnalyser(info, filename), selectionScript_(sele),
63 <      evaluator_(info), seleMan_(info){
61 >                                         double rCut, int lNumber, int nbins) : StaticAnalyser(info, filename), selectionScript_(sele), evaluator_(info), seleMan_(info){
62      
63 <    setOutputName(getPrefix(filename) + ".obo");
63 >    setOutputName(getPrefix(filename) + ".bo");
64  
65      evaluator_.loadScriptString(sele);
66      if (!evaluator_.isDynamic()) {
# Line 73 | Line 71 | namespace oopse {
71  
72      lNumber_ = lNumber;
73      rCut_ = rCut;
74 <    mSize_ = 2*lNumber_+1;    
74 >    mSize_ = 2*lNumber_+1;  
75  
76 <    // Set the l for the spherical harmonic, it doesn't change
76 >    // Q can take values from 0 to 1
77  
78 <    sphericalHarmonic.setL(lNumber_);
78 >    MinQ_ = 0.0;
79 >    MaxQ_ = 3.0;
80 >    deltaQ_ = (MaxQ_ - MinQ_) / nbins;
81 >    Q_histogram_.resize(nbins);
82  
83 <    delta_Q = 1.0 / nbins;
84 <    delta_W = 2.0 / nbins;
83 >    // W_6 for icosahedral clusters is 11 / sqrt(4199) = 0.169754, so we'll
84 >    // use values for MinW_ and MaxW_ that are slightly larger than this:
85  
86 <    Q_histogram_.resize(nbins);
86 >    MinW_ = -0.18;
87 >    MaxW_ = 0.18;
88 >    deltaW_ = (MaxW_ - MinW_) / nbins;
89      W_histogram_.resize(nbins);
90  
91    }
92  
93 +  BondOrderParameter::~BondOrderParameter() {
94 +    Q_histogram_.clear();
95 +    W_histogram_.clear();
96 +  }
97 +
98    void BondOrderParameter::initalizeHistogram() {
99      std::fill(Q_histogram_.begin(), Q_histogram_.end(), 0);
100      std::fill(W_histogram_.begin(), W_histogram_.end(), 0);
# Line 96 | Line 104 | namespace oopse {
104      Molecule* mol;
105      Atom* atom;
106      RigidBody* rb;
107 +    int myIndex;
108      SimInfo::MoleculeIterator mi;
109      Molecule::RigidBodyIterator rbIter;
110      Molecule::AtomIterator ai;
111      StuntDouble* sd;
112 <    RealType theta;
112 >    Vector3d vec;
113 >    RealType costheta;
114      RealType phi;
115      RealType r;
116      RealType dist;
117 <    std::map<int, RealType> QBar_lm;
117 >    std::map<int,ComplexType> q_lm;
118 >    std::map<int,ComplexType> QBar_lm;
119      RealType QSq_l;
120      RealType Q_l;
121 <    int nBonds;
122 <    RealSphericalHarmonic sphericalHarmonic;
121 >    ComplexType W_l;
122 >    ComplexType W_l_hat;
123 >    int nBonds, Nbonds;
124 >    SphericalHarmonic sphericalHarmonic;
125      int i, j;
126 <  
127 <  
126 >    // Make arrays for Wigner3jm
127 >    double* THRCOF = new double[mSize_];
128 >    // Variables for Wigner routine
129 >    double l_ = (double)lNumber_;
130 >    double m1Pass, m2Min, m2Max;
131 >    int error, m1, m2, m3;
132 >
133 >    // Set the l for the spherical harmonic, it doesn't change
134 >    sphericalHarmonic.setL(lNumber_);
135 >
136      DumpReader reader(info_, dumpFilename_);    
137      int nFrames = reader.getNFrames();
138 +    frameCounter_ = 0;
139  
118 –
140      for (int istep = 0; istep < nFrames; istep += step_) {
141        reader.readFrame(istep);
142 +      frameCounter_++;
143        currentSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot();
144        
145        if (evaluator_.isDynamic()) {
# Line 132 | Line 154 | namespace oopse {
154               rb = mol->nextRigidBody(rbIter)) {
155            rb->updateAtoms();
156          }        
157 <      }      
158 <      
157 >      }          
158 >            
159        // outer loop is over the selected StuntDoubles:
160  
161        for (sd = seleMan_.beginSelected(i); sd != NULL;
162             sd = seleMan_.nextSelected(i)) {
163  
164 <        // For this central atom, zero out nBonds and QBar_lm
143 <
164 >        myIndex = sd->getGlobalIndex();
165          nBonds = 0;
145 –      
166          for (int m = -lNumber_; m <= lNumber_; m++) {
167 <          QBar_lm[m] = 0.0;
167 >          q_lm[m] = 0.0;
168          }
169          
170          // inner loop is over all other atoms in the system:
# Line 154 | Line 174 | namespace oopse {
174            for (atom = mol->beginAtom(ai); atom != NULL;
175                 atom = mol->nextAtom(ai)) {
176  
177 +            if (atom->getGlobalIndex() != myIndex) {
178  
179 <            Vector3d vec = sd->getPos() - atom->getPos();      
180 <            currentSnapshot_->wrapVector(vec);
181 <            
182 <            // Calculate "bonds" and build Q_lm(r) where
183 <            //      Q_lm = Y_lm(theta(r),phi(r))                
184 <            // The spherical harmonics are wrt any arbitrary coordinate
185 <            // system, we choose standard spherical coordinates
186 <            
187 <            r = sqrt(pow(vec.x(),2)+pow(vec.y(),2)+pow(vec.z(),2));
188 <            
189 <            // Check to see if neighbor is in bond cutoff
190 <            
191 <            if (r < rCut_) {            
192 <              theta = atan2(vec.y(), vec.x());
193 <              phi = acos(vec.z()/r);
194 <              for(int m = -lNumber_; m <= lNumber_; m++){
195 <                sphericalHarmonic.setM(m);
196 <                QBar_lm[m] += sphericalHarmonic.getValueAt(theta,phi);
197 <              }
198 <              nBonds++;
199 <            }  
179 >              vec = sd->getPos() - atom->getPos();      
180 >              currentSnapshot_->wrapVector(vec);
181 >              
182 >              // Calculate "bonds" and build Q_lm(r) where
183 >              //      Q_lm = Y_lm(theta(r),phi(r))                
184 >              // The spherical harmonics are wrt any arbitrary coordinate
185 >              // system, we choose standard spherical coordinates
186 >              
187 >              r = vec.length();
188 >              
189 >              // Check to see if neighbor is in bond cutoff
190 >              
191 >              if (r < rCut_) {
192 >                costheta = vec.z() / r;
193 >                phi = atan2(vec.y(), vec.x());
194 >                
195 >                for(int m = -lNumber_; m <= lNumber_; m++){
196 >                  sphericalHarmonic.setM(m);
197 >                  q_lm[m] += sphericalHarmonic.getValueAt(costheta, phi);
198 >                }
199 >                nBonds++;
200 >              }  
201 >            }
202            }
203          }
204 <        
205 <        // Normalize Qbar
206 <        for (int m = -lNumber_;m <= lNumber_; m++){
207 <          QBar_lm[m] /= nBonds;
208 <        }
204 >        RealType ql = 0.0;
205 >        for(int m=-lNumber_; m<=lNumber_; m++) {          
206 >          ql += norm(QBar_lm[m]);
207 >        }        
208 >        ql *= 4.0*NumericConstant::PI/(RealType)(2*lNumber_+1);
209 >        collectHistogram(sqrt(ql)/(RealType)nBonds);
210  
211 <        // Find second order invariant Q_l
212 <
213 <        QSq_l = 0.0;
190 <        for (int m = -lNumber_; m <= lNumber_; m++){
191 <          QSq_l += pow(QBar_lm[m], 2);  
192 <        }
193 <        Q_l = sqrt(QSq_l*(4.0 * NumericConstant::PI / (2.0*(RealType)lNumber_ + 1)));
194 <    
195 <        // Find Third Order Invariant W_l
196 <
197 <        // Make arrays for Wigner3jm
198 <        double* THRCOF = new double[mSize_];
199 <        // Variables for Wigner routine
200 <        double l_ = (double)lNumber_;
201 <        double m2Min, m2Max;
202 <        int error, m1, m2, m3;
203 <        
204 <        W_l_ = 0.0;
205 <        for (int m1 = -lNumber_; m1 <= lNumber_; m1++) {
206 <          // Zero work array
207 <          for (int ii = 0; ii < mSize_; ii+){
208 <            THRCOF[i] = 0.0;
209 <          }
210 <          // Get Wigner coefficients
211 <          Wigner3jm(&l_, &l_, &l_, &(double)m1, &m2Min, &m2Max, THRCOF, &mSize_, &error);
212 <          for (int m_index = 1; i < (int)(m2Max - m2Min-1.0); m_index++) {
213 <            m2 = floor(m2Min) + m_index - 1;
214 <            m3 = -m1-m2;
215 <            W_l_ += THRCOF[m_index]*QBar_lm[m1+lNumber_]*QBar_lm[m2+lNumber_]*QBar_lm[m3+lNumber_];
216 <          }
211 >        Nbonds += nBonds;
212 >        for (int m=-lNumber_; m<=lNumber_; m++) {
213 >          QBar_lm[m] += q_lm[m];
214          }
218 –
219 –        W_l_hat = W_l_ / pow(QSq_l, 1.5);
220 –
221 –        // accumulate histogram data for Q_l and W_l_hat:
222 –
223 –        collectHistogram(Q_l, W_l_hat);
224 –                
215        }
216      }
217 +
218 +    // Normalize Qbar2
219 +    for (int m = -lNumber_;m <= lNumber_; m++){
220 +      QBar_lm[m] /= Nbonds;
221 +    }
222      
223 <    // Normalize by number of frames
223 >    // Find second order invariant Q_l
224 >    
225 >    QSq_l = 0.0;
226      for (int m = -lNumber_; m <= lNumber_; m++){
227 <      QBar_lm[m] /=  nFrames;  
227 >      QSq_l += norm(QBar_lm[m]);
228      }
229      
230 <    
231 <    
235 <    
236 <    
237 <    writeOrderParameter();
230 >    std::cout << "qsl = " << QSq_l << "\n";
231 >    Q_l = sqrt(QSq_l * 4.0 * NumericConstant::PI / (RealType)(2*lNumber_ + 1));
232      
233 <  }
240 <
241 <  
242 <  void BondOrderParameter::processHistogram() {
233 >    // Find Third Order Invariant W_l
234      
235 <    int nPairs = getNPairs();
236 <    RealType volume = info_->getSnapshotManager()->getCurrentSnapshot()->getVolume();
237 <    RealType pairDensity = nPairs /volume * 2.0;
238 <    RealType pairConstant = ( 4.0 * NumericConstant::PI * pairDensity ) / 3.0;
239 <
240 <    for(int i = 0 ; i < histogram_.size(); ++i){
241 <
242 <      RealType rLower = i * deltaR_;
243 <      RealType rUpper = rLower + deltaR_;
244 <      RealType volSlice = ( rUpper * rUpper * rUpper ) - ( rLower * rLower * rLower );
245 <      RealType nIdeal = volSlice * pairConstant;
246 <
247 <      avgGofr_[i] += histogram_[i] / nIdeal;    
235 >    W_l = 0.0;
236 >    for (int m1 = -lNumber_; m1 <= lNumber_; m1++) {
237 >      // Zero work array
238 >      for (int ii = 0; ii < mSize_; ii++){
239 >        THRCOF[ii] = 0.0;
240 >      }
241 >      // Get Wigner coefficients
242 >      m1Pass = (double)m1;
243 >      
244 >      Wigner3jm(&l_, &l_, &l_,
245 >                &m1Pass, &m2Min, &m2Max,
246 >                THRCOF, &mSize_, &error);
247 >      
248 >      for (int mmm = 0; mmm < (int)(m2Max - m2Min); mmm++) {
249 >        m2 = (int)floor(m2Min) + mmm;
250 >        m3 = -m1-m2;
251 >        W_l += THRCOF[mmm] * QBar_lm[m1] * QBar_lm[m2] * QBar_lm[m3];
252 >      }
253      }
254 <
254 >    
255 >    W_l_hat = W_l / pow(QSq_l, 1.5);              
256 >    
257 >    writeOrderParameter(Q_l, real(W_l_hat));    
258    }
259  
260 <  void BondOrderParameter::collectHistogram(RealType Q_l, RealType W_l_hat) {
260 >  void BondOrderParameter::collectHistogram(RealType q_l) {
261  
262 <    if (Q_l < Max_Q) {
263 <      int whichBin = Q_l / deltaQ_;
264 <      Q_histogram_[whichBin] += 1;
262 >    if (q_l >= MinQ_ && q_l < MaxQ_) {
263 >      int qbin = (q_l - MinQ_) / deltaQ_;
264 >      Q_histogram_[qbin] += 1;
265 >      Qcount_++;
266 >      sumQ_ += q_l;
267 >      sumQ2_ += q_l * q_l;
268 >    } else {
269 >      sprintf( painCave.errMsg,
270 >               "q_l value outside reasonable range\n");
271 >      painCave.severity = OOPSE_ERROR;
272 >      painCave.isFatal = 1;
273 >      simError();  
274      }
267 –    if (W_l_hat < Max_W) {
268 –      int whichBin = W_l_hat / deltaW_;
269 –      W_histogram_[whichBin] += 1;
270 –    }
271 –  }
272 –  
275  
276 <  void BondOrderParameter::writeOrderParameter() {
276 >  }  
277  
276 –    std::ofstream os(getOutputFileName().c_str());
277 –    os << "#Bond Order Parameter\n";
278 –    os << "#selection: (" << selectionScript_ << ")\n";
278  
279 <    for (std::size_t i = 0; i < orderParams_.size(); ++i) {
281 <      os <<  orderParams_[i].p2 << "\t"
282 <         <<  orderParams_[i].director[0] << "\t"
283 <         <<  orderParams_[i].director[1] << "\t"
284 <         <<  orderParams_[i].director[2] << "\t"
285 <         <<  orderParams_[i].angle << "\n";
279 >  void BondOrderParameter::writeOrderParameter(RealType ql, RealType Wlhat) {
280  
281 <    }
288 <  }
281 >    std::ofstream os(getOutputFileName().c_str());
282  
283 +    if (os.is_open()) {
284 +      
285 +      os << "# Bond Order Parameters\n";
286 +      os << "# selection: (" << selectionScript_ << ")\n";
287 +      os << "# \n";
288 +      os << "# <Q_" << lNumber_ << ">: " << ql << "\n";
289 +      os << "# <W_" << lNumber_ << ">: " << Wlhat << "\n";
290 +      // Normalize by number of frames and write it out:
291 +      for (int i = 0; i < Q_histogram_.size(); ++i) {
292 +        RealType Qval = MinQ_ + (i + 0.5) * deltaQ_;
293 +        os << Qval << "\t" << (RealType)Q_histogram_[i] / (RealType)Qcount_ << "\n";
294 +      }
295  
296 +      os.close();
297  
298 +    } else {
299 +      sprintf(painCave.errMsg, "BondOrderParameter: unable to open %s\n",
300 +              getOutputFileName().c_str());
301 +      painCave.isFatal = 1;
302 +      simError();  
303 +    }
304 +  }
305   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines