void EpsilonGridNE::Rdf(const double dx, const double cut){
vector<IndexedMatrix> Rdf;
RdfData.clear();
int nrdf=static_cast<int> ((cut/dx)+1);
vector<HistData> rdf(nrdf);
try{
if(!is_COset) throw " Must provide Metric ";
if(!is_xRefset) throw " Must provide reference point ";
}
catch(const char * s){
std::cerr << s << std::endl;
exit(1);
}
Dvect M_avg_t;
Dvect P_t=0.0;
for(int i=0;i< nnx;i++)
for(int j=0;j<nny;j++)
for(int k=0;k<nnz;k++)
for(int o=0;o<DIM;o++)
P_t[o]+=M[i][j][k][o];
for(int o=0;o<DIM;o++) P_t[o]*=this->getDV();
M_avg=P_t;
double fact1=Parameters::efact_nm/Parameters::kT300/Parameters::unitc/1000.0;
cout << fact1<< " " << Parameters::kT300 << " " << Parameters::efact_nm/1000.0 << " " << Parameters::unitc << endl;
for(unsigned int i=0;i<nnx;i++){
for(unsigned int j=0;j<nny;j++){
for(unsigned int k=0;k<nnz;k++){
Dvect M_l=M[i][j][k];
Dvect E_l=E[i][j][k];
}
}
}
Dvect xa;
const Dvect & x=xRef;
xa[XX] = oc[XX][XX] * x[XX] + oc[XX][YY] * x[YY] + oc[XX][ZZ] * x[ZZ];
xa[YY] = oc[YY][XX] * x[XX] + oc[YY][YY] * x[YY] + oc[YY][ZZ] * x[ZZ];
xa[ZZ] = oc[ZZ][XX] * x[XX] + oc[ZZ][YY] * x[YY] + oc[ZZ][ZZ] * x[ZZ];
int nx0=(int) nnx;
int ny0=(int) nny;
int nz0=(int) nnz;
double rx,ry,rz;
double rnx=1.0/ (double)(nx0);
double rny=1.0/ (double)(ny0);
double rnz=1.0/ (double)(nz0);
double dist;
Dvect xc,xd;
for(int i=0;i<nx0;i++){
rx=static_cast<double> ((i)*rnx);
for(int j=0;j<ny0;j++){
ry=static_cast<double> ((j)*rny);
for(int k=0;k<nz0;k++){
rz=static_cast<double> ((k)*rnz);
xd[XX]=rx-xa[XX];
xd[YY]=ry-xa[YY];
xd[ZZ]=rz-xa[ZZ];
xd[XX]=xd[XX]-rint(xd[XX]);
xd[YY]=xd[YY]-rint(xd[YY]);
xd[ZZ]=xd[ZZ]-rint(xd[ZZ]);
xc[XX]=co[XX][XX]*xd[XX]+co[XX][YY]*xd[YY]+co[XX][ZZ]*xd[ZZ];
xc[YY]=co[YY][XX]*xd[XX]+co[YY][YY]*xd[YY]+co[YY][ZZ]*xd[ZZ];
xc[ZZ]=co[ZZ][XX]*xd[XX]+co[ZZ][YY]*xd[YY]+co[ZZ][ZZ]*xd[ZZ];
dist=sqrt(xc[XX]*xc[XX]+xc[YY]*xc[YY]+xc[ZZ]*xc[ZZ]);
if(dist < cut){
Euler Eul(xc);
Matrix one=Matrix(0.0).Unit();
Dvect p=M[i][j][k];
Dvect e=E[i][j][k];
bool bRot=false;
Dvect LocP,LocE;
if(bRot){
LocP=Eul.Rotate(p);
LocE=Eul.Rotate(e);
}else{
LocP=p;
LocE=e;
}
int h=static_cast<int> (dist/dx);
rdf[h].e+=LocE;
rdf[h].p+=LocP;
rdf[h].idx++;
}
}
}
}
for(unsigned int i=0;i<nrdf;++i){
IndexedMatrix tmp;
if(rdf[i].idx){
tmp.p=rdf[i].p/static_cast<double> (rdf[i].idx);
tmp.e=rdf[i].e/static_cast<double> (rdf[i].idx);
tmp.i=i;
Rdf.push_back(tmp);
}
}
RdfData=Rdf;
}
NS_IMETHODIMP nsSpamSettings::GetSpamFolderURI(char **aSpamFolderURI)
{
NS_ENSURE_ARG_POINTER(aSpamFolderURI);
if (mMoveTargetMode == nsISpamSettings::MOVE_TARGET_MODE_FOLDER)
return GetActionTargetFolder(aSpamFolderURI);
// if the mode is nsISpamSettings::MOVE_TARGET_MODE_ACCOUNT
// the spam folder URI = account uri + "/Junk"
nsCString folderURI;
nsresult rv = GetActionTargetAccount(getter_Copies(folderURI));
NS_ENSURE_SUCCESS(rv,rv);
// we might be trying to get the old spam folder uri
// in order to clear the flag
// if we didn't have one, bail out.
if (folderURI.IsEmpty())
return NS_OK;
nsCOMPtr<nsIRDFService> rdf(do_GetService("@mozilla.org/rdf/rdf-service;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIRDFResource> folderResource;
rv = rdf->GetResource(folderURI, getter_AddRefs(folderResource));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr <nsIMsgFolder> folder = do_QueryInterface(folderResource);
if (!folder)
return NS_ERROR_UNEXPECTED;
nsCOMPtr <nsIMsgIncomingServer> server;
rv = folder->GetServer(getter_AddRefs(server));
NS_ENSURE_SUCCESS(rv,rv);
// see nsMsgFolder::SetPrettyName() for where the pretty name is set.
// Check for an existing junk folder - this will do a case-insensitive
// search by URI - if we find a junk folder, use its URI.
nsCOMPtr<nsIMsgFolder> junkFolder;
folderURI.Append("/Junk");
if (NS_SUCCEEDED(server->GetMsgFolderFromURI(nsnull, folderURI,
getter_AddRefs(junkFolder))) &&
junkFolder)
junkFolder->GetURI(folderURI);
// XXX todo
// better not to make base depend in imap
// but doing it here, like in nsMsgCopy.cpp
// one day, we'll fix this (and nsMsgCopy.cpp) to use GetMsgFolderFromURI()
nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryInterface(server);
if (imapServer) {
// Make sure an specific IMAP folder has correct personal namespace
// see bug #197043
nsCString folderUriWithNamespace;
(void)imapServer->GetUriWithNamespacePrefixIfNecessary(kPersonalNamespace, folderURI,
folderUriWithNamespace);
if (!folderUriWithNamespace.IsEmpty())
folderURI = folderUriWithNamespace;
}
*aSpamFolderURI = ToNewCString(folderURI);
if (!*aSpamFolderURI)
return NS_ERROR_OUT_OF_MEMORY;
else
return rv;
}
void
V1P_Process(struct req *req, struct busyobj *bo, int fd)
{
struct worker *wrk;
struct pollfd fds[2];
int i;
struct acct_pipe acct_pipe;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);
wrk = req->wrk;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
assert(fd > 0);
req->res_mode = RES_PIPE;
memset(&acct_pipe, 0, sizeof acct_pipe);
acct_pipe.req = req->acct.req_hdrbytes;
req->acct.req_hdrbytes = 0;
CHECK_OBJ_NOTNULL(bo->htc, HTTP_CONN_MAGIC);
CHECK_OBJ_NOTNULL(bo->htc->vbc, VBC_MAGIC);
bo->wrk = req->wrk;
bo->director_state = DIR_S_BODY;
(void)VTCP_blocking(fd);
V1L_Reserve(wrk, wrk->aws, &fd, bo->vsl, req->t_req);
acct_pipe.bereq += HTTP1_Write(wrk, bo->bereq, HTTP1_Req);
if (req->htc->pipeline_b != NULL)
acct_pipe.in += V1L_Write(wrk, req->htc->pipeline_b,
req->htc->pipeline_e - req->htc->pipeline_b);
i = V1L_FlushRelease(wrk);
VSLb_ts_req(req, "Pipe", W_TIM_real(wrk));
if (i == 0) {
if (bo->htc->vbc->state == VBC_STATE_STOLEN)
VBT_Wait(req->wrk, bo->htc->vbc);
memset(fds, 0, sizeof fds);
fds[0].fd = fd;
fds[0].events = POLLIN | POLLERR;
fds[1].fd = req->sp->fd;
fds[1].events = POLLIN | POLLERR;
while (fds[0].fd > -1 || fds[1].fd > -1) {
fds[0].revents = 0;
fds[1].revents = 0;
i = poll(fds, 2,
(int)(cache_param->pipe_timeout * 1e3));
if (i < 1)
break;
if (fds[0].revents &&
rdf(fd, req->sp->fd, &acct_pipe.out)) {
if (fds[1].fd == -1)
break;
(void)shutdown(fd, SHUT_RD);
(void)shutdown(req->sp->fd, SHUT_WR);
fds[0].events = 0;
fds[0].fd = -1;
}
if (fds[1].revents &&
rdf(req->sp->fd, fd, &acct_pipe.in)) {
if (fds[0].fd == -1)
break;
(void)shutdown(req->sp->fd, SHUT_RD);
(void)shutdown(fd, SHUT_WR);
fds[1].events = 0;
fds[1].fd = -1;
}
}
}
VSLb_ts_req(req, "PipeSess", W_TIM_real(wrk));
pipecharge(req, &acct_pipe, bo->htc->vbc->backend->vsc);
SES_Close(req->sp, SC_TX_PIPE);
bo->doclose = SC_TX_PIPE;
}
////////////////////////////////////////////////////////////////////////////////////
// Utility Functions for MsgFolders
////////////////////////////////////////////////////////////////////////////////////
nsresult
LocateMessageFolder(nsIMsgIdentity *userIdentity,
nsMsgDeliverMode aFolderType,
const char *aFolderURI,
nsIMsgFolder **msgFolder)
{
nsresult rv = NS_OK;
if (!msgFolder) return NS_ERROR_NULL_POINTER;
*msgFolder = nullptr;
if (!aFolderURI || !*aFolderURI)
return NS_ERROR_INVALID_ARG;
// as long as it doesn't start with anyfolder://
if (PL_strncasecmp(ANY_SERVER, aFolderURI, strlen(aFolderURI)) != 0)
{
nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
if (NS_FAILED(rv)) return rv;
// get the corresponding RDF resource
// RDF will create the folder resource if it doesn't already exist
nsCOMPtr<nsIRDFResource> resource;
rv = rdf->GetResource(nsDependentCString(aFolderURI), getter_AddRefs(resource));
if (NS_FAILED(rv)) return rv;
nsCOMPtr <nsIMsgFolder> folderResource;
folderResource = do_QueryInterface(resource, &rv);
if (NS_SUCCEEDED(rv) && folderResource)
{
// don't check validity of folder - caller will handle creating it
nsCOMPtr<nsIMsgIncomingServer> server;
//make sure that folder hierarchy is built so that legitimate parent-child relationship is established
rv = folderResource->GetServer(getter_AddRefs(server));
NS_ENSURE_SUCCESS(rv,rv);
return server->GetMsgFolderFromURI(folderResource, nsDependentCString(aFolderURI), msgFolder);
}
else
{
return NS_ERROR_FAILURE;
}
}
else
{
uint32_t cnt = 0;
uint32_t i;
if (!userIdentity)
return NS_ERROR_INVALID_ARG;
// get the account manager
nsCOMPtr<nsIMsgAccountManager> accountManager =
do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
// If any folder will do, go look for one.
nsCOMPtr<nsIArray> retval;
accountManager->GetServersForIdentity(userIdentity, getter_AddRefs(retval));
if (!retval) return NS_ERROR_FAILURE;
// Ok, we have to look through the servers and try to find the server that
// has a valid folder of the type that interests us...
rv = retval->GetLength(&cnt);
if (NS_FAILED(rv)) return rv;
for (i=0; i<cnt; i++) {
// Now that we have the server...we need to get the named message folder
nsCOMPtr<nsIMsgIncomingServer> inServer;
inServer = do_QueryElementAt(retval, i, &rv);
if(NS_FAILED(rv) || (!inServer))
continue;
//
// If aFolderURI is passed in, then the user has chosen a specific
// mail folder to save the message, but if it is null, just find the
// first one and make that work. The folder is specified as a URI, like
// the following:
//
// mailbox://nobody@Local Folders/Sent
// imap://rhp@nsmail-2/Drafts
// newsgroup://news.mozilla.org/netscape.test
//
nsCString serverURI;
rv = inServer->GetServerURI(serverURI);
if (NS_FAILED(rv) || serverURI.IsEmpty())
continue;
nsCOMPtr<nsIMsgFolder> rootFolder;
rv = inServer->GetRootFolder(getter_AddRefs(rootFolder));
if(NS_FAILED(rv) || (!rootFolder))
continue;
// use the defaults by getting the folder by flags
if (aFolderType == nsIMsgSend::nsMsgQueueForLater ||
aFolderType == nsIMsgSend::nsMsgDeliverBackground)
{
// QueueForLater (Outbox)
rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Queue, msgFolder);
}
else if (aFolderType == nsIMsgSend::nsMsgSaveAsDraft) // SaveAsDraft (Drafts)
{
rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Drafts, msgFolder);
}
else if (aFolderType == nsIMsgSend::nsMsgSaveAsTemplate) // SaveAsTemplate (Templates)
{
rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Templates, msgFolder);
}
else // SaveInSentFolder (Sent) - nsMsgDeliverNow or nsMsgSendUnsent
{
rootFolder->GetFolderWithFlags(nsMsgFolderFlags::SentMail, msgFolder);
}
if (*msgFolder)
{
return NS_OK;
}
}
}
return NS_ERROR_FAILURE;
}
void
nsImapOfflineSync::ProcessAppendMsgOperation(nsIMsgOfflineImapOperation *currentOp, PRInt32 opType)
{
nsCOMPtr <nsIMsgDBHdr> mailHdr;
nsMsgKey msgKey;
currentOp->GetMessageKey(&msgKey);
nsresult rv = m_currentDB->GetMsgHdrForKey(msgKey, getter_AddRefs(mailHdr));
if (NS_SUCCEEDED(rv) && mailHdr)
{
nsMsgKey messageOffset;
PRUint32 messageSize;
mailHdr->GetMessageOffset(&messageOffset);
mailHdr->GetOfflineMessageSize(&messageSize);
nsCOMPtr<nsIFile> tmpFile;
if (NS_FAILED(GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR,
"nscpmsg.txt",
getter_AddRefs(tmpFile))))
return;
if (NS_FAILED(tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600)))
return;
nsCOMPtr <nsIOutputStream> outputStream;
rv = MsgNewBufferedFileOutputStream(getter_AddRefs(outputStream), tmpFile, PR_WRONLY | PR_CREATE_FILE, 00600);
if (NS_SUCCEEDED(rv) && outputStream)
{
nsCString moveDestination;
currentOp->GetDestinationFolderURI(getter_Copies(moveDestination));
nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
nsCOMPtr<nsIRDFResource> res;
if (NS_FAILED(rv)) return ; // ### return error code.
rv = rdf->GetResource(moveDestination, getter_AddRefs(res));
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIMsgFolder> destFolder(do_QueryInterface(res, &rv));
if (NS_SUCCEEDED(rv) && destFolder)
{
nsCOMPtr <nsIInputStream> offlineStoreInputStream;
rv = destFolder->GetOfflineStoreInputStream(getter_AddRefs(offlineStoreInputStream));
if (NS_SUCCEEDED(rv) && offlineStoreInputStream)
{
nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(offlineStoreInputStream);
NS_ASSERTION(seekStream, "non seekable stream - can't read from offline msg");
if (seekStream)
{
rv = seekStream->Seek(PR_SEEK_SET, messageOffset);
if (NS_SUCCEEDED(rv))
{
// now, copy the dest folder offline store msg to the temp file
PRInt32 inputBufferSize = 10240;
char *inputBuffer = nsnull;
while (!inputBuffer && (inputBufferSize >= 512))
{
inputBuffer = (char *) PR_Malloc(inputBufferSize);
if (!inputBuffer)
inputBufferSize /= 2;
}
PRInt32 bytesLeft;
PRUint32 bytesRead, bytesWritten;
bytesLeft = messageSize;
rv = NS_OK;
while (bytesLeft > 0 && NS_SUCCEEDED(rv))
{
PRInt32 bytesToRead = PR_MIN(inputBufferSize, bytesLeft);
rv = offlineStoreInputStream->Read(inputBuffer, bytesToRead, &bytesRead);
if (NS_SUCCEEDED(rv) && bytesRead > 0)
{
rv = outputStream->Write(inputBuffer, bytesRead, &bytesWritten);
NS_ASSERTION(bytesWritten == bytesRead, "wrote out correct number of bytes");
}
else
break;
bytesLeft -= bytesRead;
}
outputStream->Flush();
outputStream->Close();
if (NS_SUCCEEDED(rv))
{
m_curTempFile = do_QueryInterface(tmpFile);
nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID);
if (copyService)
rv = copyService->CopyFileMessage(tmpFile, destFolder,
/* nsIMsgDBHdr* msgToReplace */ nsnull,
PR_TRUE /* isDraftOrTemplate */,
0, // new msg flags - are there interesting flags here?
EmptyCString(), /* are there keywords we should get? */
this,
m_window);
}
else
tmpFile->Remove(PR_FALSE);
}
currentOp->SetPlayingBack(PR_TRUE);
m_currentOpsToClear.AppendObject(currentOp);
m_currentDB->DeleteHeader(mailHdr, nsnull, PR_TRUE, PR_TRUE);
}
}
// want to close in failure case too
outputStream->Close();
}
}
}
}
}
void
PipeSession(struct sess *sp)
{
struct vbc *vc;
struct worker *w;
struct pollfd fds[2];
int i;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
CHECK_OBJ_NOTNULL(sp->wrk, WORKER_MAGIC);
w = sp->wrk;
sp->vbc = VDI_GetFd(NULL, sp);
if (sp->vbc == NULL)
return;
vc = sp->vbc;
(void)VTCP_blocking(vc->fd);
WRW_Reserve(w, &vc->fd);
sp->wrk->acct_tmp.hdrbytes +=
http_Write(w, sp->vsl_id, sp->wrk->bereq, 0);
if (sp->htc->pipeline.b != NULL)
sp->wrk->acct_tmp.bodybytes +=
WRW_Write(w, sp->htc->pipeline.b, Tlen(sp->htc->pipeline));
i = WRW_FlushRelease(w);
if (i) {
SES_Close(sp, "pipe");
VDI_CloseFd(sp);
return;
}
sp->t_resp = VTIM_real();
memset(fds, 0, sizeof fds);
// XXX: not yet (void)VTCP_linger(vc->fd, 0);
fds[0].fd = vc->fd;
fds[0].events = POLLIN | POLLERR;
// XXX: not yet (void)VTCP_linger(sp->fd, 0);
fds[1].fd = sp->fd;
fds[1].events = POLLIN | POLLERR;
while (fds[0].fd > -1 || fds[1].fd > -1) {
fds[0].revents = 0;
fds[1].revents = 0;
i = poll(fds, 2, params->pipe_timeout * 1000);
if (i < 1)
break;
if (fds[0].revents && rdf(vc->fd, sp->fd)) {
if (fds[1].fd == -1)
break;
(void)shutdown(vc->fd, SHUT_RD);
(void)shutdown(sp->fd, SHUT_WR);
fds[0].events = 0;
fds[0].fd = -1;
}
if (fds[1].revents && rdf(sp->fd, vc->fd)) {
if (fds[0].fd == -1)
break;
(void)shutdown(sp->fd, SHUT_RD);
(void)shutdown(vc->fd, SHUT_WR);
fds[1].events = 0;
fds[1].fd = -1;
}
}
SES_Close(sp, "pipe");
VDI_CloseFd(sp);
}
void
PipeRequest(struct req *req)
{
struct vbc *vc;
struct worker *wrk;
struct pollfd fds[2];
struct busyobj *bo;
int i;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);
wrk = req->wrk;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
bo = req->busyobj;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
vc = VDI_GetFd(NULL, bo);
if (vc == NULL)
return;
bo->vbc = vc; /* For panic dumping */
(void)VTCP_blocking(vc->fd);
WRW_Reserve(wrk, &vc->fd, bo->vsl, req->t_req);
req->acct_req.hdrbytes += HTTP1_Write(wrk, bo->bereq, 0);
if (req->htc->pipeline.b != NULL)
req->acct_req.bodybytes +=
WRW_Write(wrk, req->htc->pipeline.b,
Tlen(req->htc->pipeline));
i = WRW_FlushRelease(wrk);
if (i) {
SES_Close(req->sp, SC_TX_PIPE);
VDI_CloseFd(&vc);
return;
}
req->t_resp = VTIM_real();
memset(fds, 0, sizeof fds);
// XXX: not yet (void)VTCP_linger(vc->fd, 0);
fds[0].fd = vc->fd;
fds[0].events = POLLIN | POLLERR;
// XXX: not yet (void)VTCP_linger(req->sp->fd, 0);
fds[1].fd = req->sp->fd;
fds[1].events = POLLIN | POLLERR;
while (fds[0].fd > -1 || fds[1].fd > -1) {
fds[0].revents = 0;
fds[1].revents = 0;
i = poll(fds, 2, cache_param->pipe_timeout * 1000);
if (i < 1)
break;
if (fds[0].revents && rdf(vc->fd, req->sp->fd)) {
if (fds[1].fd == -1)
break;
(void)shutdown(vc->fd, SHUT_RD);
(void)shutdown(req->sp->fd, SHUT_WR);
fds[0].events = 0;
fds[0].fd = -1;
}
if (fds[1].revents && rdf(req->sp->fd, vc->fd)) {
if (fds[0].fd == -1)
break;
(void)shutdown(req->sp->fd, SHUT_RD);
(void)shutdown(vc->fd, SHUT_WR);
fds[1].events = 0;
fds[1].fd = -1;
}
}
SES_Close(req->sp, SC_TX_PIPE);
VDI_CloseFd(&vc);
bo->vbc = NULL;
}
